get e set são parte das Propriedades do C#, elas englobam o conceito de Encapsulamento da
programação Orientada a Objetos. Em outras linguagens como C++, Java etc, o encapsulamento é feito através de dois métodos, um para retornar o valor de um campo de uma classe, e outro para setar um valor nesse campo, que obviamente vai trabalhar com
um parâmetro para receber o valor que irá setar no campo da classe.
class MyClass
{
private:
string name;
public:
string GetName();
void SetName(string newName);
}
string MyClass::GetName()
{
return this->name;
}
void MyClass::SetName(string newName)
{
if (newName != "Invalid Name")
this->name = newName;
}
Acima um exemplo de encapsulamento em C++, como eu disse, nessas linguagens usam-se dois métodos para obter ou setar o valor de um campo da classe. Mas no C#, foram introduzidas a Propriedades, que tem o mesmo objetivo, encapsular os campos das classes,
e permitir pegar o valor deles, ou setar um valor para eles, permitindo estabelecer regras de como isso acontecerá. Em termos intuítivos, as Propriedades do C# nada mais são do que dois métodos, get e set, que você teria em outras linguagens; porém, em uma
unica Propriedade, permitindo um acesso mais fácil e direto, ao invez de ter que se referir a um método "Get" para obter o valor de um campo, e um método "Set" para setar um novo valor para um campo de classe.
public class MyClass
{
private string _name;
public string Name
{
get
{
if (_name != "")
return _name;
}
set
{
if (value != "Invalid Name")
_name = value;
}
}
}
Percebeu? A ideia das Propriedades no C# é facilitar o uso do Encapsulamento, fazendo que uma unica "variavel" sirva para dar acesso ao campo da classe, e criar regras para esse acesso, como fazemos quando criamos métodos para encapsular campos
de classes em outras linguagens como C++ e Java.
Note que, nas outras linguagens, o método que permitirá a atribuição de um novo ao campo funciona com um parâmetro, pro qual será passado o novo valor, para ser testado ou atribuído na hora. Nas Propriedades do C#, como você tem uma unica Propriedade para
ambas as operações, Obter e Atribuir, usa-se a palavre chave value, que nada mais é do que o valor que está sendo passado quando o
uso da propriedade é para atribuição de valores.
Não vou mentir, no começo as Propriedades são difíceis de entender, principalmente a questão do set e o value. Mas não é muito complicado entender como usar as Propriedades, segue mais um exemplo:
public class People
{
private string _name;
// O TIPO da propriedade deve ser o mesmo
// Do campo, pois retornará e receberá
// Esse TIPO de dados/valor.
public string Name
{
// Retornará o valor do campo
// Em operações de acesso de valor.
get { return _name; }
// Pegara o valor passado em
// Operações de atribuição
// E colocará no campo.
// OBS.: A palavra-chave 'value'
// Contém o valor passado para a
// Propriedade na hora da atribuição.
set { _name = value; }
}
public People()
{
_name = "Some People";
}
}
public static class Program
{
static void Main(string[] args)
{
People p = new People();
// Acesso do valor do campo "_name"
// Atravez da propriedade Name
// Aqui é como um "GetName()"
// Em C++ ou Java por exemplo.
Console.WriteLine(p.Name);
// Uso da mesma Propriedade
// Porém, para setar um novo valor
// Aqui quem é chamado é o set da Pripriedade
// Algo como "SetName(string newName)"
// Em outras linguagens.
// A string "New Johnson Name" está
// Sendo passada para o set, que está
// Pegando esse valor atravez da
// Palavra-Chave 'value'.
p.Name = "New Johnson Name";
// Novamente, usando a mesma Propriedade
// Porém, acessando o valor do campo "_name"
// Que acabou de ser modificado atravez da mesma
// Propriedade.
Console.WriteLine(p.Name);
Console.ReadLine();
}
}
Viu como é fácil? Bom, espero que você consiga entender. Abraços!
