Die erste Programmiersprache, die ich gelernt habe, war Java, aber ich habe das Konzept und das Schreiben von C # -Eigenschaften nicht wirklich verstanden, deshalb möchte ich es organisieren.
Betrachten Sie die ** menschliche Klasse **, die in objektorientierten Erklärungen häufig vorkommt. Angenommen, die Klasse Mensch hat die folgenden Felder und Sichtbarkeiten:
--nickname …… Sie können den Spitznamen leicht ändern. Es gibt keine Einschränkungen und Sie können frei abrufen und neu schreiben. --realname …… Der echte Name kann nicht so einfach geändert werden. Also kann ich es herausnehmen, aber ich kann es nicht umschreiben. ――Alter …… Alter kann Makrele lesen, also werde ich es dieses Mal umschreiben. Da es sich jedoch um ein Alter handelt, muss es mindestens 0 Jahre alt sein.
Um diese Anforderung zu erfüllen, sollte die Klasse folgendermaßen aussehen:
--nickname: Ich habe beide Getter / Setter. --realname: Nur Getter haben. --age: Ich habe einen Getter und einen Conditional Setter.
Außerdem definieren wir dieses Mal einen Konstruktor, der dieses Feld gleichzeitig mit der Instanziierung festlegen kann.
Java Im Fall von Java wird viel geschrieben, aber es ist einfach zu tun. Felder, die ehrlich definiert werden sollten, werden als private Variablen definiert, und Getter / Setter werden nur als öffentliche Methoden definiert. Wenn Sie ein Limit setzen möchten, schreiben Sie die Logik in die Methode. Wenn Sie überhaupt nicht darauf zugreifen möchten, müssen Sie lediglich eine Methode schreiben. Der Konstruktor nimmt auch die Argumente der Reihe nach und setzt sie in seine eigenen Felder.
public class Main {
public static void main(String[] args) throws Exception {
Human konan = new Human("Shinichi Kudo", "Aber Kudo", 17);
//Sie können Ihren Spitznamen, Ihren richtigen Namen und Ihr Alter frei abrufen.
System.out.println(konan.getNickname()); // ->Aber Kudo
System.out.println(konan.getRealname()); // ->Shinichi Kudo
System.out.println(konan.getAge()); // -> 17
//Spitzname und Alter können umgeschrieben werden
konan.setNickname("Conan Edogawa");
konan.setAge(7);
System.out.println(konan.getNickname()); // ->Conan Edogawa
System.out.println(konan.getAge()); // -> 7
//Selbst wenn Sie ein seltsames Alter eingeben, wird es ignoriert
konan.setAge(-10000);
System.out.println(konan.getAge()); // ->Bleibt 7
//Sie können Ihren richtigen Namen nicht ändern.
// konan.setRealname("Conan Edogawa"); // ->Ich werde wütend, weil es keine solche Methode gibt.
//Dann Conan, wie heißt du wirklich?
System.out.println(konan.getRealname()); // ->Shinichi Kudo. Ah ... schließlich.
}
}
class Human{
private String realname;
private String nickname;
private int age;
public Human(String realname, String nickname, int age){
this.realname = realname;
this.nickname = nickname;
if (age >= 0){
this.age = age;
}
}
public String getRealname(){
return realname;
}
public String getNickname(){
return nickname;
}
public void setNickname(String nickname){
this.nickname = nickname;
}
public int getAge(){
return age;
}
public void setAge(int age){
if (age >= 0){
this.age = age;
}
}
}
In der Human-Klasse gibt es viel Code. Dieses Mal habe ich Bedingungen und Einschränkungen festgelegt, damit ich mich nicht so unangenehm fühle, aber wenn praktisch alle Felder zugänglich sind und All-you-can-eat-Kurse angeboten werden, fühle ich mich unfruchtbar. In einigen Fällen kann die Bibliothek mit dem Namen Lombok etwas sauberer geschrieben werden, und in anderen Fällen wird die Getter / Setter-Methode automatisch mithilfe der IDE-Funktion generiert, die jedoch an eine andere Person übergeben wird.
Daher scheint es, dass moderne Sprachen häufig eine spezielle Art des Schreibens ihrer eigenen Felder (obwohl sie auch als Attribute bezeichnet werden) Getter / Setter implementieren. C # ist einer von ihnen.
C# In C # wird eine Funktion namens properties verwendet, um Felder von außen neu zu schreiben und abzurufen. Es sieht so aus, als würden Sie das Feld direkt umschreiben. Da es sich jedoch tatsächlich um eine Getter / Setter-Methode handelt, wird dies in ** Pascal-Fall ** geschrieben (in C # lautet der Methodenname Pascal-Fall). Wenn Sie Eigenschaften verwenden, haben Sie nicht das Gefühl, jedes Mal eine Methode zu durchlaufen, und Sie haben das Gefühl, dass Sie direkt zuweisen oder referenzieren.
using System;
public class Program
{
public static void Main()
{
Human konan = new Human("Shinichi Kudo","Aber Kudo",17);
//Sie können Ihren Spitznamen, Ihren richtigen Namen und Ihr Alter frei abrufen.
Console.WriteLine(konan.Nickname); // ->Aber Kudo
Console.WriteLine(konan.Realname); // ->Shinichi Kudo
Console.WriteLine(konan.Age); // -> 17
//Der Spitzname und das Alter können umgeschrieben werden.
konan.Nickname = "Conan Edogawa";
konan.Age = 7;
Console.WriteLine(konan.Nickname); // ->Conan Edogawa
Console.WriteLine(konan.Age); // ->7
//Selbst wenn Sie ein seltsames Alter eingeben, wird es ignoriert
konan.Age = -10000;
Console.WriteLine(konan.Age); // ->Bleibt 7
//Sie können Ihren richtigen Namen nicht ändern
// konan.Realname = "Conan Edogawa"; //Seine Eigenschaft ist Lesen-Sei wütend auf Only
//Dann Conan, wie heißt du wirklich?
Console.WriteLine(konan.Realname); // ->Shinichi Kudo. Ah ... schließlich.
}
}
class Human
{
public string Realname{ get; }
public string Nickname{ get; set; }
private int age;
public int Age
{
get
{
return this.age;
}
set{
if (value >= 0)
{
this.age = value;
}
}
}
public Human(string realname, string nickname, int age)
{
this.Realname = realname;
this.Nickname = nickname;
if (age >= 0)
{
this.Age = age;
}
}
}
Wenn Sie eine Eigenschaft verwenden möchten, die gelesen oder geschrieben werden kann, schreiben Sie einfach {get; set;} nach dem Eigenschaftsnamen. Wenn Sie die schreibgeschützte Eigenschaft verwenden möchten, verwenden Sie {get;} [^ 1]. Wenn Sie nach einer internen Verarbeitung beim Festlegen oder Abrufen zurückkehren oder festlegen möchten, bereiten Sie ein separates Feld (dies ist eine normale Variable, also Kamelfall) und nach der Eigenschaftsdeklaration vor Schreiben Sie wie folgt.
[^ 1]: ~~ Tatsächlich scheint die schreibgeschützte Eigenschaft in C # nicht unterstützt zu werden. In diesem Fall wird es separat als normale Setter-Methode implementiert. ~~ Wenn Sie private get verwenden, können Sie schreibgeschützte Eigenschaften verwenden (siehe Postscript).
{
get
{
//Etwas zu verarbeiten
return Verarbeitetes Ergebnis;
}
set
{
//Etwas mit Wert verarbeitet
this.Feld=Ergebnis der Verarbeitung;
}
}
Zu diesem Zeitpunkt wird innerhalb des Setzers der empfangene Wert automatisch mit dem Argument "Wert" empfangen.
Da einige Eigenschaften diesmal schreibgeschützt sind, sieht der Konstruktor wie Java aus. Wenn jedoch alle Eigenschaften über Schreibberechtigung verfügen, müssen Sie keinen Konstruktor vorbereiten. Sie können so etwas schreiben: Es ist sehr sauber.
Human konan = new Human(){ Realname = "Shinichi Kudo", Nickname = "Aber Kudo", Age = 17 };
Es gibt viele Gespräche über die Vor- und Nachteile von Getter / Setter, aber es gibt immer noch einige Dinge, die nicht vermieden werden können, wenn über objektorientierte Kapselung gesprochen wird. Da ich aus Java stamme, verstehe ich, dass Objekte nur Variablen und Methoden haben. Obwohl es leicht zu verstehen war, hatte ich den Eindruck, dass es überflüssig und mühsam war.
Als ich den C # -Code zum ersten Mal sah, kannte ich nicht einmal die Funktion von Eigenschaften. Warum schreibt dieser Typ also Variablen im Pascal-Fall? Ich dachte, aber als ich es nachschlug, war ich beeindruckt, dass es so präzise geschrieben werden konnte. Wenn jedoch Logik in Getter / Setter enthalten ist, wird sie leicht verzögert und schwer zu erkennen sein, und da sich der Schreibstil um diese herum mit jedem Versions-Upgrade von C # während der Untersuchung weiterentwickelt Ich hatte den Eindruck, dass es ziemlich verwirrend war, weil viele Informationen wie "Ich kann so schreiben" und "Ich habe früher so geschrieben" herauskamen und ich verwirrt war.
Dieser Artikel ist auch eine Zusammenfassung für mich. Wir hoffen, dieser Artikel hat Ihnen geholfen, Ihr C # -Leben zu verbessern.
Da ich im obigen Artikel vergessen habe zu schreiben, können Sie den C # -Eigenschaften Anfangswerte geben. Wenn Sie beispielsweise einem neugeborenen menschlichen Objekt den Namen "anonym" geben möchten, können Sie es wie folgt schreiben, ohne ein Feld vorbereiten zu müssen, um es zu initialisieren oder einen Konstruktor zu definieren.
string name{ get; set; } = "Anonym";
Dies allein ist nett, aber nützlich, wenn Sie beispielsweise ein Objekt einer Klasse als Eigenschaft in der Klasse haben möchten.
class Human{
public List<string> Tools{ get; set; } = new List<string>();
}
Auf diese Weise können Sie diese Eigenschaft plötzlich von außerhalb der Objekte dieser Klasse bearbeiten.
var konan = new Human();
konan.Tools.Add("Sprachwechsler");
konan.Tools.Add("Kick Power Enhancement Schuhe");
konan.Tools.Add("Anästhesiepistole beobachten");
Wenn Sie dies versuchen, ohne die Eigenschaften zu initialisieren, erhalten Sie eine NullReferenceException. Um dies zu vermeiden, müssen Sie außerhalb der Klasse neu sein und dann bleiben.
(Thx: C # er von der gleichen Firma)
Im ersten Artikel habe ich geschrieben, dass die schreibgeschützte Eigenschaft nicht verwendet werden kann, aber in Wirklichkeit scheint es, dass sie verwendet werden kann, indem sie zu einer "privaten get" -Eigenschaft gemacht wird. Sie können Ihre Eigenschaften nicht einmal im Inneren lesen.
Deshalb,
public string Secret { set; }
Kann aber nicht geschrieben werden
public string Secret { private get; set; }
Kann geschrieben werden als.
var konan = new Human();
konan.Secret = "In der Tat Shinichi";
// Console.WriteLine(konan.Secret); ←Write-Sei wütend auf Only
(Thx: @muniel)
Dieses Mal habe ich es unter der Annahme geschrieben, dass einige Verarbeitungen am Setter durchgeführt werden, also habe ich den Typ int verwendet, aber es scheint einen Typ namens uint type (Unsigned Int) zu geben, der als vorzeichenlose Ganzzahl bezeichnet wird. Der Typ int verarbeitet -2147483648 bis 2147483647, während der Typ uint 0 bis 4294967295 verarbeitet.
Da der uint-Typ beispielsweise grundsätzlich keine negativen Zahlen verarbeiten kann, wird "10-20" nicht zu "-10", sondern zu "4294967286" (aufgrund der Bitoperation dreht er sich um und stürzt in die größere). Es kann aufgrund unerwarteten Verhaltens eine Brutstätte für Fehler sein. Grundsätzlich scheint es, dass der Typ uint nicht für den Wert verwendet werden sollte, der das Ziel der Arithmetik sein kann.
Wenn Sie jedoch wirklich ein menschliches Objekt erstellen möchten, wird durch Festlegen des Alters für eine festgelegte / abrufbare Eigenschaft das Alter jedes Jahr aktualisiert, sodass Sie wahrscheinlich einen Geburtstag als Eigenschaft im Inneren haben, und das Alter basiert darauf. Es scheint gut, es zu einer Get-Only-Eigenschaft zu machen, die einen Wert berechnet und zurückgibt. (Thx: @ Tonbo0710, @ tak458, @ Zuishin)
public Human(string realname, string nickname, int age)
{
this.Realname = realname;
this.Nickname = nickname;
if (age >= 0)
{
this.Age = age;
}
}
Im obigen Artikel wird die if-Anweisung verwendet, um zu verhindern, dass auch im Konstruktor seltsame Werte eingefügt werden. Wenn Sie jedoch sorgfältig darüber nachdenken, legen Sie den Wert hier über Ihre eigene Eigenschaft und in diesem Setter fest Da es nach beurteilt wird, sollte dies wie folgt geschrieben werden [^ 2]. Darüber hinaus kann "dies" vorhanden sein oder nicht, da die Eigenschaft und der Name der empfangenen Variablen in den Fällen Pascal und Kamel nicht in Konflikt stehen.
public Human(string realname, string nickname, int age)
{
this.Realname = realname;
this.Nickname = nickname;
this.Age = age;
}
(Thx: Yamada)
[^ 2]: Es scheint, dass Sie nur im Konstruktor von außen setzen können, ohne private set zu schreiben.
Recommended Posts