Öffentliche Felder versus automatische Eigenschaften

Uns wird oft gesagt, wir sollten die Kapselung schützen, indem wir Getter- und Setter-Methoden (Eigenschaften in C #) für Klassenfelder erstellen, anstatt die Felder der Außenwelt auszusetzen.

Es gibt jedoch viele Fälle, in denen ein Feld nur dazu dient, einen Wert zu speichern, und für dessen Abruf oder Festlegung keine Berechnung erforderlich ist. Für diese würden wir alle diese Nummer machen:

public class Book
{
    private string _title;

    public string Title
    {
          get{ return _title;  }
          set{ _title = value; }
    }
}

Nun, ich habe ein Geständnis, ich konnte es nicht ertragen, all das zu schreiben (wirklich, es musste nicht geschrieben werden, es musste angeschaut werden), also wurde ich Schurke und benutzte öffentliche Felder.

Dann kommt C # 3.0 und ich sehe, dass sie automatische Eigenschaften hinzugefügt haben:

public class Book
{
    public string Title {get; set;} 
}

Was ist aufgeräumter und ich bin dankbar dafür, aber was ist wirklich so anders, als nur ein öffentliches Feld zu schaffen?

public class Book
{
    public string Title;
}

In einer verwandten Frage, die ich vor einiger Zeit hatte, gab es einen Link zu einem Beitrag in Jeffs Blog, der einige Unterschiede erklärte.

Eigenschaften vs. öffentliche Variablen

• Die Reflexion funktioniert bei Variablen im Vergleich zu Eigenschaften unterschiedlich. Wenn Sie sich also auf die Reflexion verlassen, ist es einfacher, alle Eigenschaften zu verwenden.
• Sie können keine Datenbindung für eine Variable vornehmen.

• Das Ändern einer Variablen in eine Eigenschaft ist eine wichtige Änderung. Zum Beispiel:

  TryGetTitle(out book.Title); // requires a variable

Wenn ich die API-Probleme ignoriere, finde ich das Debuggen am wertvollsten an der Verwendung einer Eigenschaft.

Der CLR-Debugger unterstützt keine Datenunterbrechungspunkte (die meisten nativen Debugger tun dies). Daher ist es nicht möglich, einen Haltepunkt beim Lesen oder Schreiben eines bestimmten Felds in einer Klasse festzulegen. Dies ist in bestimmten Debugging-Szenarien sehr einschränkend.

Da Eigenschaften als sehr dünne Methoden implementiert werden, ist es möglich, Haltepunkte beim Lesen und Schreiben ihrer Werte festzulegen. Dies gibt ihnen ein großes Bein über Felder.

Der Wechsel von einem Feld zu einer Eigenschaft bricht den Vertrag (z. B. muss der gesamte Referenzcode neu kompiliert werden). Wenn Sie also einen Interaktionspunkt mit anderen Klassen haben - einem öffentlichen (und allgemein geschützten) Mitglied - möchten Sie zukünftiges Wachstum planen. Verwenden Sie dazu immer Eigenschaften.

Es ist nichts, was es heute zu einer Auto-Eigenschaft macht, und 3 Monate später wird klar, dass Sie es faul laden möchten, und einen Null-Check in den Getter setzen. Wenn Sie ein Feld verwendet haben, ist dies im besten Fall eine Neukompilierungsänderung und im schlimmsten Fall unmöglich, je nachdem, wer und was sonst noch von Ihren Baugruppen abhängt.

Nur weil es niemand erwähnt hat: Sie können keine Felder auf Schnittstellen definieren. Wenn Sie also eine bestimmte Schnittstelle implementieren müssen, die Eigenschaften definiert, sind Auto-Eigenschaften manchmal eine wirklich nette Funktion.

Ein großer Unterschied, der oft übersehen wird und in keiner anderen Antwort erwähnt wird: Überschreiben . Sie können Eigenschaften als virtuell deklarieren und überschreiben, während Sie dies für öffentliche Mitgliedsfelder nicht tun können.

Es geht um Versionierung und API-Stabilität. In Version 1 gibt es keinen Unterschied - aber später, wenn Sie entscheiden, dass Sie dies zu einer Eigenschaft mit einer Art Fehlerprüfung in Version 2 machen müssen, müssen Sie Ihre API nicht ändern - keine Codeänderungen, irgendwo anders als die Definition der Eigenschaft.

Ein weiterer Vorteil von automatisch implementierten Eigenschaften gegenüber öffentlichen Feldern besteht darin, dass Sie Set-Accessoren privat oder geschützt machen können, wodurch die Klasse von Objekten, für die sie definiert wurde, besser gesteuert werden kann als die von öffentlichen Feldern.

Es ist nichts Falsches daran, ein Feld zu erstellen public. Denken Sie jedoch daran, dass das Erstellen getter/settermit privateFeldern keine Kapselung ist. IMO, wenn Sie sich nicht für andere Funktionen von a interessieren Property, können Sie es genauso gut machen public.

Wenn Sie später entscheiden, ob der Titel eindeutig ist, indem Sie ihn mit einer Sammlung oder einer Datenbank vergleichen, können Sie dies in der Eigenschaft tun, ohne den davon abhängigen Code zu ändern.

Wenn Sie nur ein öffentliches Attribut verwenden, haben Sie weniger Flexibilität.

Die zusätzliche Flexibilität ohne Vertragsbruch ist für mich das Wichtigste bei der Verwendung von Eigenschaften. Bis ich die Flexibilität tatsächlich benötige, ist die automatische Generierung am sinnvollsten.

Eine Sache, die ich ebenso nützlich finde wie alle Code- und Testgründe, ist, dass wenn es sich um eine Eigenschaft gegenüber einem Feld handelt, die Visual Studio-IDE Ihnen die Referenzen für eine Eigenschaft, aber kein Feld anzeigt.

Mein Pov hat danach einige Nachforschungen angestellt

1. Validierung.
2. Ermöglichen Sie dem Überschreiben des Accessors, das Verhalten einer Eigenschaft zu ändern.
3. Debugging-Zweck. Wir können wissen, wann und was sich an der Eigenschaft ändert, indem wir im Accessor einen Haltepunkt setzen.
4. Wir können nur ein Feldset haben. Zum Beispiel public set () und private get (). Dies ist im öffentlichen Bereich nicht möglich.

Es gibt uns wirklich mehr Möglichkeiten und Erweiterbarkeit.