Bien que les champs et les propriétés semblent similaires, ce sont deux éléments de langage complètement différents.
Les champs sont le seul mécanisme permettant de stocker des données au niveau de la classe. Les champs sont conceptuellement des variables au niveau de la classe. Si vous souhaitez stocker des données dans des instances de vos classes (objets), vous devez utiliser des champs. Il n'y a pas d'autre choix. Les propriétés ne peuvent pas stocker de données même si elles semblent pouvoir le faire. Voir ci-dessous.
En revanche, les propriétés ne stockent jamais de données. Ce ne sont que les paires de méthodes (get et set) qui peuvent être appelées syntaxiquement de la même manière que les champs et dans la plupart des cas, elles accèdent (pour la lecture ou l'écriture) aux champs, ce qui est source de confusion. Mais comme les méthodes de propriété sont (avec quelques limitations comme le prototype fixe) des méthodes C # régulières, elles peuvent faire tout ce que les méthodes régulières peuvent faire. Cela signifie qu'ils peuvent avoir 1000 lignes de code, ils peuvent lever des exceptions, appeler d'autres méthodes, peuvent même être virtuels, abstraits ou remplacés. Ce qui rend les propriétés spéciales, c'est le fait que le compilateur C # stocke des métadonnées supplémentaires dans des assemblys qui peuvent être utilisés pour rechercher des propriétés spécifiques - fonctionnalité largement utilisée.
Les méthodes d'obtention et de définition des propriétés comportent les prototypes suivants.
PROPERTY_TYPE get();
void set(PROPERTY_TYPE value);
Cela signifie donc que les propriétés peuvent être «émulées» en définissant un champ et 2 méthodes correspondantes.
class PropertyEmulation
{
private string MSomeValue;
public string GetSomeValue()
{
return(MSomeValue);
}
public void SetSomeValue(string value)
{
MSomeValue=value;
}
}
Une telle émulation de propriété est typique des langages de programmation qui ne prennent pas en charge les propriétés, comme le C ++ standard. En C #, vous devriez toujours préférer les propriétés comme moyen d'accéder à vos champs.
Étant donné que seuls les champs peuvent stocker des données, cela signifie que plus de classe de champs contient, plus d'objets mémoire de cette classe consommeront. D'un autre côté, l'ajout de nouvelles propriétés dans une classe n'agrandit pas les objets de cette classe. Voici l'exemple.
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).
Bien que les méthodes de propriété puissent tout faire, dans la plupart des cas, elles permettent d'accéder aux champs des objets. Si vous souhaitez rendre un champ accessible à d'autres classes, vous pouvez le faire de 2 manières.
- Rendre les champs publics - déconseillé.
- Utilisation des propriétés.
Voici une classe utilisant des champs publics.
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;
Bien que le code soit parfaitement valide, du point de vue de la conception, il présente plusieurs inconvénients. Étant donné que les champs peuvent être à la fois lus et écrits, vous ne pouvez pas empêcher l'utilisateur d'écrire dans les champs. Vous pouvez appliquer un readonlymot clé, mais de cette manière, vous devez initialiser les champs en lecture seule uniquement dans le constructeur. De plus, rien ne vous empêche de stocker des valeurs invalides dans vos champs.
name.FullName=null;
name.YearOfBirth=2200;
name.Age=-140;
Le code est valide, toutes les affectations seront exécutées bien qu'elles soient illogiques. Agea une valeur négative, YearOfBirthest loin dans le futur et ne correspond pas à l'âge et FullNameest nul. Avec les champs, vous ne pouvez pas empêcher les utilisateurs de class Namefaire de telles erreurs.
Voici un code avec des propriétés qui corrige ces problèmes.
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());
}
}
}
La version mise à jour de la classe présente les avantages suivants.
FullName et YearOfBirth sont vérifiés pour les valeurs non valides.Agen'est pas inscriptible. Il est calculé à partir deYearOfBirth l'année en cours.- Une nouvelle propriété est
FullNameInUppercaseconvertie FullNameen MAJUSCULE. Ceci est un petit exemple artificiel d'utilisation des propriétés, où les propriétés sont couramment utilisées pour présenter les valeurs de champ dans le format qui convient le mieux à l'utilisateur - par exemple en utilisant les paramètres régionaux actuels sur un DateTimeformat numérique spécifique .
À côté de cela, les propriétés peuvent être définies comme virtuelles ou remplacées - simplement parce que ce sont des méthodes .NET normales. Les mêmes règles s'appliquent pour ces méthodes de propriété que pour les méthodes normales.
C # prend également en charge les indexeurs qui sont les propriétés qui ont un paramètre d'index dans les méthodes de propriété. Voici l'exemple.
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]);
Depuis C # 3.0 vous permet de définir des propriétés automatiques. Voici l'exemple.
class AutoProps
{
public int Value1
{
get;
set;
}
public int Value2
{
get;
set;
}
}
Même s'il class AutoPropsne contient que des propriétés (ou il ressemble), il peut stocker 2 valeurs et la taille des objets de cette classe est égale àsizeof(Value1)+sizeof(Value2) = 4 + 4 = 8 octets.
La raison en est simple. Lorsque vous définissez une propriété automatique, le compilateur C # génère du code automatique qui contient un champ masqué et une propriété avec des méthodes de propriété accédant à ce champ masqué. Voici le compilateur de code produit.
Voici un code généré par l' ILSpy à partir d'un assemblage compilé. La classe contient les champs et propriétés masqués générés.
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;
}
}
}
Ainsi, comme vous pouvez le voir, le compilateur utilise toujours les champs pour stocker les valeurs - car les champs sont le seul moyen de stocker des valeurs dans des objets.
Donc, comme vous pouvez le voir, bien que les propriétés et les champs aient une syntaxe d'utilisation similaire, ce sont des concepts très différents.Même si vous utilisez des propriétés ou des événements automatiques - les champs masqués sont générés par le compilateur où les données réelles sont stockées.
Si vous devez rendre une valeur de champ accessible au monde extérieur (utilisateurs de votre classe), n'utilisez pas de champs publics ou protégés. Les champs doivent toujours être marqués comme privés. Les propriétés vous permettent d'effectuer des vérifications de valeurs, de formatage, de conversions, etc. et rendent généralement votre code plus sûr, plus lisible et plus extensible pour de futures modifications.