Soll ich Objekte mit oder ohne private Felder bevorzugen?

Die Codebasis, in der ich gerade arbeite, verwendet standardmäßig private Felder und öffentliche Eigenschaften. Zum Beispiel haben die meisten Klassen ihre Mitglieder wie folgt definiert:

// Fields
private double _foo;
private double _bar;
private double _baz;

// Properties
public double Foo
{
    get{ return _foo; }
    set{ _foo = value; }
}

public double Bar
{
    get{ return _bar; }
    set{ _bar = value; }
}

public double Baz
{
    get{ return _baz; }
}

Ich weiß, dass diese ohne ihre internen privaten Eigenschaften umgeschrieben werden können:

public double Foo{ get; set; }
public double Bar{ get; set; }
public double Baz{ get; private set; }

Ich hätte gerne einen Input dazu:

• Gibt es einen guten Grund, den älteren, expliziteren Stil dem neueren, prägnanteren vorzuziehen?
• Soll ich neue Klassen mit dem prägnanten Stil schreiben oder aus Gründen der Konsistenz versuchen, mit dem älteren Code übereinzustimmen? Ist Konsistenz in diesem Fall ausreichend, um das ältere Format zu rechtfertigen?

Es gibt einige Fälle, in denen der sogenannte "ältere" Stil noch erforderlich ist:

A: Unveränderliche Typen unter Verwendung der von der Sprache bereitgestellten Unveränderlichkeit. Der readonlyModifikator in C # friert diesen Wert nach der Erstellung ein. Es gibt (noch) keine Möglichkeit, dies mit automatisch implementierten Eigenschaften nachzuahmen.

public sealed class FooBarBazInator
{
    private readonly double foo;

    public FooBarBazInator(double foo)
    {
        this.foo = foo;
    }

    public double Foo
    {
        get
        {
            return this.foo;
        }
    }
}

B: Ihre Getter / Setter haben irgendeine Logik. WPF- und Silverlight-Code (und ähnlicher Code), die an Ihre Klassen gebunden sind, werden folgendermaßen implementiert INotifyPropertyChanged:

public class FooBarBazInator : INotifyPropertyChanged
{
    private double foo;

    public event PropertyChangedEventHandler PropertyChanged;

    public double Foo
    {
        get
        {
            return this.foo;
        }

        set
        {
            this.foo = value;
            this.RaisePropertyChanged("Foo");
        }
    }

    private void RaisePropertyChanged(string propertyName)
    {
        var propertyChanged = this.PropertyChanged;

        if (propertyChanged != null)
        {
            propertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Ansonsten würde ich sagen, benutze den neuen Stil. Hält Ihren Code übersichtlich und bietet weniger Fläche, auf der sich Bugs einschleichen können. Außerdem ist der Code nicht mit Signaturen kompatibel, falls er jemals geändert werden muss, um Logik einzuschließen.

Ich würde sagen, dass explizites Backing Field nur nutzloses Zeug ist: Es macht Ihren Code länger und schwieriger zu lesen. Es fügt auch Fehlerpotential hinzu:

public double Bar
{
    get { return _baz; }
    set { _bar = value; }
}

Ich denke, ein Fehler wie dieser könnte ziemlich leicht passieren und wäre ziemlich schwer zu erkennen.

Und wenn Sie Konsistenz wünschen, gehen Sie umgekehrt vor: Ändern Sie den Code, der Sicherungsfelder verwendet, in Code, der automatische Eigenschaften verwendet. Dies ist besonders einfach, wenn Sie ein Refactoring-Tool wie ReSharper verwenden (und wenn Sie so etwas nicht verwenden, sollten Sie anfangen).

Natürlich gibt es immer noch Fälle, in denen ein Hintergrundfeld erforderlich ist, aber ich denke, das ist für diese Frage nicht relevant.

Obwohl die Frage ziemlich alt ist, habe ich darüber nachgedacht, einige Punkte hinzuzufügen, die ich aus einem Buch gelesen habe, das es wert ist, hier erwähnt zu werden.

1. Die Laufzeit-Serialisierungsmodule behalten den Namen des in einem serialisierten Stream abgelegten Dokuments bei. Der Name des Sicherungsfelds für eine automatisch implementierte Eigenschaft (AIP) wird vom Compiler festgelegt. Er kann den Namen dieses Sicherungsfelds bei jeder Neukompilierung des Codes ändern, wodurch die Möglichkeit der Deserialisierung von Instanzen aller Typen negiert wird, die ein enthalten AIP. Verwenden Sie AIP daher nicht für Typen, die Sie serialisieren oder deserialisieren möchten.

2. Beim Debuggen können Sie keinen Haltepunkt für eine AIP-Methode zum Abrufen oder Festlegen festlegen, sodass Sie nicht leicht erkennen können, wann eine Anwendung diese Eigenschaft abruft oder festlegt. Sie können Haltepunkte für manuell implementierte Haltepunkte festlegen

Gibt es einen guten Grund, den älteren, expliziteren Stil dem neueren, prägnanteren vorzuziehen?

Nicht wirklich. Obwohl ich behaupten würde, dass Sie jedes Mal, wenn Sie ein Grundstück wie dieses durchquerten, ein öffentliches Feld hätten benutzen sollen.

Soll ich neue Klassen mit dem prägnanten Stil schreiben oder aus Gründen der Konsistenz versuchen, mit dem älteren Code übereinzustimmen? Ist Konsistenz in diesem Fall ausreichend, um das ältere Format zu rechtfertigen?

Unter der Annahme, dass Sie die obigen Hinweise ignoriert haben und Passthrough-Eigenschaften haben, würde ich nicht darauf abzielen, dem Stil zu entsprechen. Idealerweise würden Sie zurückgehen und den alten in den neuen Stil umgestalten, um konsistent zu sein, aber die Wahrscheinlichkeit, dass Leute diesen Code falsch lesen, ist gering.