Haruskah saya lebih suka properti dengan atau tanpa bidang pribadi?

Basis kode saya bekerja sekarang memiliki konvensi menggunakan bidang pribadi dan properti publik. Sebagai contoh, sebagian besar kelas memiliki anggota mereka didefinisikan seperti ini:

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

Saya tahu ini dapat ditulis ulang tanpa properti pribadi internal mereka:

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

Saya ingin masukan tentang ini:

• Apakah ada alasan yang baik untuk memilih gaya yang lebih lama, lebih eksplisit daripada gaya yang lebih baru, lebih ringkas?
• Haruskah saya menulis kelas baru menggunakan gaya ringkas, atau haruskah saya mencoba mencocokkan kode yang lebih lama untuk konsistensi? Apakah konsistensi cukup layak dalam hal ini untuk membenarkan format yang lebih lama?

Ada beberapa contoh di mana gaya yang disebut "lebih tua" masih diperlukan:

A: Jenis yang tidak dapat diubah menggunakan ketidakmampuan yang disediakan bahasa The readonlypengubah di C # membeku yang nilai setelah konstruksi. Tidak ada cara untuk meniru ini dengan properti yang diimplementasikan secara otomatis (belum).

public sealed class FooBarBazInator
{
    private readonly double foo;

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

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

B: Getter / setter Anda memiliki logika apa pun. WPF dan kode Silverlight (dan sejenisnya) yang terikat data ke kelas Anda akan menerapkan INotifyPropertyChangedseperti:

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

Selain itu, saya katakan menggunakan gaya baru. Buat kode Anda singkat dan menawarkan area permukaan yang lebih sedikit untuk di-bug. Selain itu, jika perlu diubah untuk memasukkan logika, itu tidak akan kompatibel dengan tanda tangan.

Saya akan mengatakan bahwa memiliki bidang dukungan eksplisit hanya omong kosong tidak berguna: itu membuat kode Anda lebih lama dan lebih sulit untuk dibaca. Ini juga menambah potensi kesalahan:

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

Saya pikir kesalahan seperti ini bisa terjadi dengan mudah dan akan sangat sulit dikenali.

Dan jika Anda menginginkan konsistensi, lakukan dengan cara lain: ubah kode yang menggunakan bidang pencadangan menjadi kode yang menggunakan properti otomatis. Ini sangat mudah jika Anda menggunakan alat refactoring seperti ReSharper (dan jika Anda tidak menggunakan sesuatu seperti itu, saya pikir Anda harus mulai).

Tentu saja, masih ada kasus di mana memiliki bidang dukungan diperlukan, tapi saya pikir itu tidak relevan dengan pertanyaan ini.

Meskipun pertanyaannya sudah cukup lama, saya berpikir untuk menambahkan beberapa poin yang saya baca dari sebuah buku yang layak disebutkan di sini.

1. Mesin serialisasi run-time bertahan nama diajukan dalam aliran serial. Nama bidang dukungan untuk properti yang diimplementasikan secara otomatis (AIP) ditentukan oleh kompiler, dan itu sebenarnya bisa mengubah nama bidang dukungan ini setiap kali Anda mengkompilasi ulang kode Anda, meniadakan kemampuan untuk menghapus tanda turunan dari semua jenis yang mengandung AIP. Jadi jangan gunakan AIP dengan jenis apa pun yang Anda ingin serialkan atau deserialize.

2. Saat men-debug, Anda tidak dapat menempatkan breakpoint pada metode AIP get atau set, sehingga Anda tidak dapat dengan mudah mendeteksi ketika aplikasi mendapatkan atau mengatur properti ini. Anda dapat mengatur breakpoint pada breakpoint yang diterapkan secara manual

Apakah ada alasan yang baik untuk memilih gaya yang lebih lama, lebih eksplisit daripada gaya yang lebih baru, lebih ringkas?

Tidak juga. Meskipun saya berpendapat bahwa setiap kali Anda melewati properti seperti itu, Anda seharusnya baru saja menggunakan bidang publik.

Haruskah saya menulis kelas baru menggunakan gaya ringkas, atau haruskah saya mencoba mencocokkan kode yang lebih lama untuk konsistensi? Apakah konsistensi cukup layak dalam hal ini untuk membenarkan format yang lebih lama?

Dengan asumsi Anda mengabaikan saran di atas dan memiliki sifat passthrough, saya tidak akan bertujuan untuk mencocokkan gaya. Idealnya, Anda akan kembali dan mengubah gaya lama menjadi gaya baru agar konsisten, tetapi kemungkinan orang salah membaca kode itu tipis.