-
So verwenden Sie C# set und get
Die C#-Sprache verfügt über zwei Funktionen – eine Zuweisungsfunktion (get) und eine Wertfunktion (set), was deutlich aus dem von ihr generierten Zwischensprachcode ersichtlich ist. C# befürwortet nicht, die Schutzstufe der Domäne auf „Öffentlich“ zu setzen und Benutzern zu erlauben, außerhalb der Klasse willkürlich zu agieren – das ist zu unOO, oder genauer gesagt, zu unsicher! Für alle Felder, die außerhalb der Klasse sichtbar sein müssen, empfiehlt C# die Verwendung von Attributen, um sie auszudrücken. Attribute stellen keine Speicherorte dar, was den grundlegenden Unterschied zwischen Attributen und Domänen ausmacht. Das Folgende ist ein typisches Attributdesign:
Verwenden des Systems;
classMyClass
{
int ganze Zahl;
public int Ganzzahl
{
get {Ganzzahl zurückgeben;}
setze {integer=value;}
}
}
Klassentest
{
öffentliches statisches void Main()
{
MyClass MyObject=new MyClass();
Console.Write(MyObject.Integer);
MyObject.Integer++;
Console.Write(MyObject.Integer);
}
}
Wie erwartet gibt das Programm 0 1 aus. Wir können sehen, dass Attribute Programmierern eine benutzerfreundliche Zugriffsschnittstelle für Domänenmitglieder bieten, indem sie Methoden umschließen. Der Wert hier ist das Schlüsselwort von C#, das der implizite Parameter von set ist, wenn wir Attributoperationen ausführen, dh der R-Wert, wenn wir Attributschreiboperationen ausführen.
Attribute stellen drei Schnittstellenoperationen bereit: schreibgeschützt (get), schreibgeschützt (set) und Lese-/Schreibzugriff (get und set). Diese drei Vorgänge in der Domäne müssen unter demselben Attributnamen deklariert werden und können nicht getrennt werden. Siehe die folgende Implementierung:
classMyClass
{
privater String-Name;
öffentlicher String-Name
{
get { return name }
}
öffentlicher String-Name
{
set {name = value;
}
}
Die obige Methode zum Trennen der Implementierung des Namensattributs ist falsch! Wir sollten sie wie im vorherigen Beispiel zusammenfügen. Es ist erwähnenswert, dass C# die drei Eigenschaften (schreibgeschützt, schreibgeschützt, Lese-/Schreibzugriff) als denselben Eigenschaftsnamen betrachtet, siehe das folgende Beispiel:
classMyClass
{
protected int num=0;
öffentliche int Num
{
Satz
{
num=Wert;
}
}
}
Klasse MyClassDerived: MyClass
{
neue öffentliche int Num
{
erhalten
{
Rückgabenummer;
}
}
}
Klassentest
{
öffentliches statisches void Main()
{
MyClassDerived MyObject = new MyClassDerived();
//MyObject.Num= 1; //Fehler!
((MyClass)MyObject).Num = 1;
}
}
Wir können sehen, dass das Attribut Num-get{} in MyClassDerived die Definition des Attributs Num-set{} in MyClass blockiert.
Natürlich sind Attribute weit mehr als nur Domänenschnittstellenoperationen. Beim Extrahieren oder Zuweisen von Attributen können wir bestimmte Prüfungen, Warnungen und andere zusätzliche Operationen durchführen.
classMyClass
{
privater String-Name;
öffentlicher String-Name
{
get { return name }
Satz
{
if (Wert==null)
name="Microsoft";
anders
Name=Wert;
}
}
}
Aufgrund der Art der Attributmethode weisen Attribute natürlich auch verschiedene Methodenmodifikationen auf. Attribute haben auch 5 Zugriffsmodifikatoren, aber die Zugriffsmodifikatoren von Attributen sind oft öffentlich, sonst verlieren wir die Bedeutung von Attributen als öffentliche Schnittstellen von Klassen. Zusätzlich zum Fehlen von Feature-Attributen wie der Methodenüberladung, die durch mehrere Parameter der Methode verursacht werden, haben Modifikatoren wie Virtual, Sealed, Override und Abstract das gleiche Verhalten für Attribute und Methoden, da Attribute jedoch im Wesentlichen als zwei Methoden implementiert sind , es Bestimmte Verhaltensweisen erfordern unsere Aufmerksamkeit. Schauen Sie sich das folgende Beispiel an:
abstrakte Klasse A
{
int y;
öffentliches virtuelles int X
{
get { return 0 }
}
öffentliches virtuelles int Y
{
get { return y }
set {y = value;
}
public abstract int Z { get;
}
Klasse B: A
{
int z;
öffentliche Überschreibung int X
{
get { return base.X + 1 }
}
öffentliche Überschreibung int Y
{
set {base.Y = value < 0? 0: value;
}
öffentliche Überschreibung int Z
{
get { return z }
set { z = value }
}
}
Dieses Beispiel verdeutlicht einige typische Verhaltensweisen von Eigenschaften im Zusammenhang mit der Vererbung. Hier muss Klasse A aufgrund der Existenz des abstrakten Attributs Z als abstrakt deklariert werden. Unterklasse B verweist über das Basisschlüsselwort auf die Attribute der übergeordneten Klasse A. Klasse B kann die virtuellen Attribute in Klasse A nur durch Y-Set überschreiben.
Statische Eigenschaften können wie statische Methoden nur auf statische Domänenvariablen der Klasse zugreifen. Wir können auch externe Eigenschaften deklarieren, genau wie wir es mit externen Methoden tun.