-
Comment utiliser C# set et obtenir
Le langage C# a deux fonctions : une fonction d'affectation (get) et une fonction de valeur (set), qui sont clairement visibles à partir du code de langage intermédiaire qu'il génère. C# ne préconise pas de définir le niveau de protection du domaine sur public et de permettre aux utilisateurs d'opérer arbitrairement en dehors de la classe - c'est trop unOO, ou pour être plus précis, trop dangereux ! Pour tous les champs qui doivent être visibles en dehors de la classe, C# recommande d'utiliser des attributs pour les exprimer. Les attributs ne représentent pas les emplacements de stockage, ce qui constitue la différence fondamentale entre les attributs et les domaines. Voici une conception d’attribut typique :
utiliser le système ;
classeMaClasse
{
entier entier ;
public int Entier
{
obtenir {retour entier ;}
définir {entier=valeur ;}
}
}
Test de classe
{
public static void Main()
{
MaClasse MonObject=new MaClasse();
Console.Write(MonObjet.Integer);
MonObjet.Integer++;
Console.Write(MonObjet.Integer);
}
}
Comme prévu, le programme génère 0 1. Nous pouvons voir que les attributs fournissent aux programmeurs une interface d'accès conviviale aux membres du domaine en encapsulant des méthodes. La valeur ici est le mot-clé de C#, qui est le paramètre implicite de set lorsque nous effectuons des opérations d'attribut, c'est-à-dire la rvalue lorsque nous effectuons des opérations d'écriture d'attribut.
Les attributs fournissent trois opérations d'interface : lecture seule (get), écriture seule (set) et lecture-écriture (get et set). Ces trois opérations sur le domaine doivent être déclarées sous le même nom d'attribut et ne peuvent être séparées. Voir l'implémentation suivante :
classeMaClasse
{
nom de chaîne privée ;
chaîne publique Nom
{
obtenir {nom de retour }
}
chaîne publique Nom
{
définir { nom = valeur }
}
}
La méthode ci-dessus pour séparer l'implémentation de l'attribut Name est erronée ! Nous devrions les assembler comme dans l’exemple précédent. Il convient de noter que les trois propriétés (lecture seule, écriture seule, lecture-écriture) sont considérées comme étant le même nom de propriété par C#, voir l'exemple suivant :
classeMaClasse
{
protégé int num=0 ;
public int Nombre
{
ensemble
{
num=valeur ;
}
}
}
classe MaClasseDerived : MaClasse
{
nouveau public int Nombre
{
obtenir
{
retourner num ;
}
}
}
Test de classe
{
public static void Main()
{
MyClassDerived MyObject = new MyClassDerived();
//MonObjet.Num= 1; //Erreur !
((MaClasse)MonObjet).Num = 1;
}
}
On voit que l'attribut Num-get{} dans MyClassDerived bloque la définition de l'attribut Num-set{} dans MyClass.
Bien sûr, les attributs sont bien plus que de simples opérations d'interface de domaine. L'essence des attributs reste les méthodes. Nous pouvons effectuer certaines vérifications, avertissements et autres opérations supplémentaires basées sur la logique du programme lors de l'extraction ou de l'attribution d'attributs.
classeMaClasse
{
nom de chaîne privée ;
chaîne publique Nom
{
obtenir {nom de retour }
ensemble
{
si (valeur==null)
nom="Microsoft";
autre
nom=valeur ;
}
}
}
En raison de la nature de la méthode des attributs, les attributs ont bien sûr également diverses modifications de méthodes. Les attributs ont également 5 modificateurs d'accès, mais les modificateurs d'accès des attributs sont souvent publics, sinon nous perdrons le sens des attributs en tant qu'interfaces publiques des classes. En plus du manque d'attributs de fonctionnalités tels que la surcharge de méthode apportée par plusieurs paramètres de la méthode, les modificateurs tels que virtual, scellé, override et abstract ont le même comportement pour les attributs et les méthodes, car les attributs sont essentiellement implémentés comme deux méthodes. , certains comportements nécessitent notre attention. Regardez l'exemple suivant :
classe abstraite A
{
int y;
public virtuel int X
{
obtenir { retourner 0 ;
}
public virtuel int Y
{
obtenir { retourner y }
définir { y = valeur }
}
public abstrait int Z { obtenir ;
}
classe B : A
{
entier z ;
remplacement public int X
{
obtenir { return base.X + 1 }
}
remplacement public int Y
{
set { base.Y = valeur < 0 ? 0 : valeur ;
}
remplacement public int Z
{
obtenir { retourner z ;
définir { z = valeur }
}
}
Cet exemple met en évidence un comportement typique des propriétés dans le contexte de l'héritage. Ici, la classe A doit être déclarée abstraite en raison de l'existence de l'attribut abstrait Z. La sous-classe B fait référence aux attributs de la classe parent A via le mot-clé base. La classe B peut écraser les attributs virtuels de la classe A uniquement via Y-set.
Les propriétés statiques, comme les méthodes statiques, ne peuvent accéder qu'aux variables de domaine statiques de la classe. Nous pouvons également déclarer des propriétés externes, tout comme nous le faisons pour des méthodes externes.