Czy powinienem preferować nieruchomości z polami prywatnymi lub bez nich?

Baza kodów, w której teraz pracuję, ma konwencję korzystania z prywatnych pól i właściwości publicznych. Na przykład większość klas ma takich członków zdefiniowanych w ten sposób:

// 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; }
}

Wiem, że można je przepisać bez ich wewnętrznych właściwości prywatnych:

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

Chciałbym coś w tym zakresie:

• Czy jest dobry powód, aby preferować starsze, bardziej wyraźne style niż nowsze, bardziej zwięzłe?
• Czy powinienem pisać nowe klasy w zwięzłym stylu, czy powinienem starać się dopasować starszy kod w celu zachowania spójności? Czy w tym przypadku spójność jest wystarczająca, aby uzasadnić starszy format?

Istnieje kilka przypadków, w których wymagany jest tak zwany „starszy” styl:

Odp .: Niezmienne typy wykorzystujące niezmienność podaną w języku. readonlyModyfikator C # zawiesza się tę wartość po zakończeniu budowy. Nie ma możliwości naśladowania tego za pomocą automatycznie implementowanych właściwości (jeszcze).

public sealed class FooBarBazInator
{
    private readonly double foo;

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

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

B: Twoi pobierający / ustawiający mają jakąkolwiek logikę. Kod WPF i Silverlight (i podobne), które są powiązane z danymi w twoich klasach, będą implementować w następujący INotifyPropertyChangedsposób:

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));
        }
    }
}

Poza tym powiedziałbym, że użyj nowego stylu. Utrzymuje zwięzłość kodu i oferuje mniejszą powierzchnię do wkradania się błędów. Ponadto, jeśli kiedykolwiek trzeba zmienić, aby uwzględnić logikę, nie będzie niezgodny z podpisem.

Powiedziałbym, że posiadanie wyraźnego pola kopii zapasowej jest po prostu bezużytecznym cruft: sprawia, że ​​twój kod jest dłuższy i trudniejszy do odczytania. Dodaje także potencjał błędu:

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

Myślę, że taki błąd może się zdarzyć dość łatwo i będzie trudny do wykrycia.

A jeśli chcesz spójności, zrób to w drugą stronę: zmień kod wykorzystujący pola zapasowe na kod korzystający z właściwości automatycznych. Jest to szczególnie łatwe, jeśli używasz narzędzia refaktoryzującego, takiego jak ReSharper (a jeśli nie używasz czegoś takiego, myślę, że powinieneś zacząć).

Oczywiście nadal istnieją przypadki, w których konieczne jest posiadanie pola zaplecza, ale myślę, że nie ma to związku z tym pytaniem.

Chociaż pytanie jest dość stare, pomyślałem o dodaniu kilku punktów, które przeczytałem z książki, o której warto tu wspomnieć.

1. Mechanizmy serializacji w czasie wykonywania zachowują nazwę pliku w serializowanym strumieniu. Nazwa pola bazowego dla właściwości Automatycznie zaimplementowanej (AIP) jest określana przez kompilator i może faktycznie zmieniać nazwę tego pola bazowego za każdym razem, gdy ponownie kompilujesz kod, co neguje możliwość deserializacji instancji dowolnego typu, które zawierają AIP Dlatego nie używaj AIP z żadnym typem, który zamierzasz serializować lub deserializować.

2. Podczas debugowania nie można ustawić punktu przerwania dla metody AIP get lub set, więc nie można łatwo wykryć, kiedy aplikacja pobiera lub ustawia tę właściwość. Możesz ustawić punkty przerwania na ręcznie zaimplementowanych punktach przerwania

Czy jest dobry powód, aby preferować starsze, bardziej wyraźne style niż nowsze, bardziej zwięzłe?

Nie całkiem. Chociaż twierdziłbym, że za każdym razem, gdy masz taką własność, powinieneś po prostu skorzystać z pola publicznego.

Czy powinienem pisać nowe klasy w zwięzłym stylu, czy powinienem starać się dopasować starszy kod w celu zachowania spójności? Czy w tym przypadku spójność jest wystarczająca, aby uzasadnić starszy format?

Zakładając, że zignorowałeś powyższe rady i posiadasz właściwości przejściowe, nie chciałbym dopasować stylu. Idealnie byłoby wrócić i zmienić stary styl na nowy, aby był spójny, ale prawdopodobieństwo, że ludzie źle odczytają ten kod, jest niewielkie.