Embora os campos e as propriedades pareçam semelhantes, são dois elementos de linguagem completamente diferentes.
Os campos são o único mecanismo de armazenamento de dados no nível da classe. Os campos são conceitualmente variáveis no escopo da classe. Se você deseja armazenar alguns dados em instâncias de suas classes (objetos), precisará usar campos. Não há outra escolha. As propriedades não podem armazenar dados, embora possa parecer que eles são capazes de fazê-lo. Veja abaixo.
As propriedades, por outro lado, nunca armazenam dados. Eles são apenas os pares de métodos (obter e definir) que podem ser chamados sintaticamente de maneira semelhante aos campos e, na maioria dos casos, acessam campos (para leitura ou gravação), que é a fonte de alguma confusão. Mas como os métodos de propriedade são (com algumas limitações, como protótipo fixo) métodos C # regulares, eles podem fazer o que os métodos regulares podem fazer. Isso significa que eles podem ter 1000 linhas de código, podem gerar exceções, chamar outros métodos, podem ser virtuais, abstratos ou substituídos. O que torna as propriedades especiais é o fato de o compilador C # armazenar alguns metadados extras em assemblies que podem ser usados para procurar propriedades específicas - recurso amplamente usado.
Os métodos de propriedade Get e set possuem os seguintes protótipos.
PROPERTY_TYPE get();
void set(PROPERTY_TYPE value);
Portanto, significa que as propriedades podem ser 'emuladas' definindo um campo e 2 métodos correspondentes.
class PropertyEmulation
{
private string MSomeValue;
public string GetSomeValue()
{
return(MSomeValue);
}
public void SetSomeValue(string value)
{
MSomeValue=value;
}
}
Essa emulação de propriedade é típica para linguagens de programação que não suportam propriedades - como C ++ padrão. Em C #, você sempre deve preferir propriedades como a maneira de acessar seus campos.
Como apenas os campos podem armazenar dados, isso significa que mais classe de campos contém, mais objetos de memória dessa classe serão consumidos. Por outro lado, adicionar novas propriedades a uma classe não aumenta os objetos dessa classe. Aqui está o exemplo.
class OneHundredFields
{
public int Field1;
public int Field2;
...
public int Field100;
}
OneHundredFields Instance=new OneHundredFields() // Variable 'Instance' consumes 100*sizeof(int) bytes of memory.
class OneHundredProperties
{
public int Property1
{
get
{
return(1000);
}
set
{
// Empty.
}
}
public int Property2
{
get
{
return(1000);
}
set
{
// Empty.
}
}
...
public int Property100
{
get
{
return(1000);
}
set
{
// Empty.
}
}
}
OneHundredProperties Instance=new OneHundredProperties() // !!!!! Variable 'Instance' consumes 0 bytes of memory. (In fact a some bytes are consumed becasue every object contais some auxiliarity data, but size doesn't depend on number of properties).
Embora os métodos de propriedade possam fazer qualquer coisa, na maioria dos casos eles servem como uma maneira de acessar os campos dos objetos. Se você deseja tornar um campo acessível a outras classes, pode fazê-lo de duas maneiras.
- Tornar os campos públicos - não é aconselhável.
- Usando propriedades.
Aqui está uma classe usando campos públicos.
class Name
{
public string FullName;
public int YearOfBirth;
public int Age;
}
Name name=new Name();
name.FullName="Tim Anderson";
name.YearOfBirth=1979;
name.Age=40;
Embora o código seja perfeitamente válido, do ponto de vista do design, ele tem várias desvantagens. Como os campos podem ser lidos e gravados, você não pode impedir que o usuário grave nos campos. Você pode aplicar a readonlypalavra-chave, mas dessa forma, você deve inicializar os campos somente leitura no construtor. Além do mais, nada impede que você armazene valores inválidos em seus campos.
name.FullName=null;
name.YearOfBirth=2200;
name.Age=-140;
O código é válido, todas as atribuições serão executadas, embora ilógicas. Agetem um valor negativo, YearOfBirthestá distante no futuro e não corresponde à idade e FullNameé nulo. Com os campos, você não pode impedir que os usuários class Namecometam esses erros.
Aqui está um código com propriedades que corrige esses problemas.
class Name
{
private string MFullName="";
private int MYearOfBirth;
public string FullName
{
get
{
return(MFullName);
}
set
{
if (value==null)
{
throw(new InvalidOperationException("Error !"));
}
MFullName=value;
}
}
public int YearOfBirth
{
get
{
return(MYearOfBirth);
}
set
{
if (MYearOfBirth<1900 || MYearOfBirth>DateTime.Now.Year)
{
throw(new InvalidOperationException("Error !"));
}
MYearOfBirth=value;
}
}
public int Age
{
get
{
return(DateTime.Now.Year-MYearOfBirth);
}
}
public string FullNameInUppercase
{
get
{
return(MFullName.ToUpper());
}
}
}
A versão atualizada da classe possui as seguintes vantagens.
FullNamee YearOfBirthsão verificados quanto a valores inválidos.Agenão é gravável. É calculado deYearOfBirth ano atual.- Uma nova propriedade é
FullNameInUppercaseconvertida FullNameem MAIÚSCULAS. Este é um exemplo um pouco artificial de uso de propriedade, em que propriedades são comumente usadas para apresentar valores de campo no formato mais apropriado para o usuário - por exemplo, usando a localidade atual em um numérico específico de DateTimeformato.
Além disso, as propriedades podem ser definidas como virtuais ou substituídas - simplesmente porque são métodos .NET regulares. As mesmas regras se aplicam aos métodos de propriedade e aos métodos regulares.
O C # também suporta indexadores, que são as propriedades que possuem um parâmetro index nos métodos de propriedade. Aqui está o exemplo.
class MyList
{
private string[] MBuffer;
public MyList()
{
MBuffer=new string[100];
}
public string this[int Index]
{
get
{
return(MBuffer[Index]);
}
set
{
MBuffer[Index]=value;
}
}
}
MyList List=new MyList();
List[10]="ABC";
Console.WriteLine(List[10]);
Como o C # 3.0 permite definir propriedades automáticas. Aqui está o exemplo.
class AutoProps
{
public int Value1
{
get;
set;
}
public int Value2
{
get;
set;
}
}
Embora class AutoPropscontenha apenas propriedades (ou parece), ele pode armazenar 2 valores e o tamanho dos objetos dessa classe é igual a sizeof(Value1)+sizeof(Value2)= 4 + 4 = 8 bytes.
A razão para isso é simples. Quando você define uma propriedade automática, o compilador C # gera código automático que contém o campo oculto e uma propriedade com métodos de propriedade acessando esse campo oculto. Aqui está o compilador de código produzido.
Aqui está um código gerado pelo ILSpy a partir do assembly compilado. A classe contém campos e propriedades ocultos gerados.
internal class AutoProps
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value1>k__BackingField;
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value2>k__BackingField;
public int Value1
{
[CompilerGenerated]
get
{
return <Value1>k__BackingField;
}
[CompilerGenerated]
set
{
<Value1>k__BackingField = value;
}
}
public int Value2
{
[CompilerGenerated]
get
{
return <Value2>k__BackingField;
}
[CompilerGenerated]
set
{
<Value2>k__BackingField = value;
}
}
}
Portanto, como você pode ver, o compilador ainda usa os campos para armazenar os valores - já que os campos são a única maneira de armazenar valores em objetos.
Portanto, como você pode ver, embora propriedades e campos tenham sintaxe de uso semelhante, eles são conceitos muito diferentes.Mesmo se você usar propriedades ou eventos automáticos - os campos ocultos são gerados pelo compilador onde os dados reais são armazenados.
Se você precisar tornar um valor de campo acessível ao mundo exterior (usuários de sua classe), não use campos públicos ou protegidos. Os campos sempre devem ser marcados como particulares. As propriedades permitem fazer verificações de valor, formatação, conversões etc. e geralmente tornam seu código mais seguro, mais legível e mais extensível para modificações futuras.