Mengapa antarmuka C # tidak bisa berisi bidang?

Sebagai contoh, misalkan saya ingin ICarantarmuka dan bahwa semua implementasi akan berisi bidang Year. Apakah ini berarti bahwa setiap implementasi harus secara terpisah menyatakan Year? Bukankah lebih baik mendefinisikannya di antarmuka saja?

Meskipun banyak jawaban lain yang benar di tingkat semantik, saya merasa menarik untuk juga mendekati pertanyaan-pertanyaan semacam ini dari tingkat rincian implementasi.

Antarmuka dapat dianggap sebagai kumpulan slot , yang berisi metode . Ketika sebuah kelas mengimplementasikan sebuah antarmuka, kelas tersebut diperlukan untuk memberi tahu runtime bagaimana mengisi semua slot yang diperlukan. Kapan kamu berkata

interface IFoo { void M(); } 
class Foo : IFoo { public void M() { ... } }

kelas mengatakan "ketika Anda membuat instance dari saya, isikan referensi untuk Foo.M di slot untuk IFoo.M.

Kemudian saat Anda melakukan panggilan:

IFoo ifoo = new Foo();
ifoo.M();

kompiler menghasilkan kode yang mengatakan "tanyakan objek metode apa yang ada di slot untuk IFoo.M, dan panggil metode itu.

Jika sebuah antarmuka adalah kumpulan slot yang berisi metode, maka beberapa slot itu juga bisa berisi metode get and set dari properti, metode get and set dari pengindeks, dan metode tambah dan hapus acara. Tapi lapangan bukan metode . Tidak ada "slot" yang terkait dengan bidang yang dapat Anda "isi" dengan referensi ke lokasi bidang. Dan karena itu, antarmuka dapat mendefinisikan metode, properti, pengindeks dan peristiwa, tetapi tidak bidang.

Antarmuka dalam C # dimaksudkan untuk mendefinisikan kontrak yang akan dipatuhi suatu kelas - bukan implementasi tertentu.

Dalam semangat itu, antarmuka C # memang memungkinkan properti untuk didefinisikan - yang pemanggil harus menyediakan implementasi untuk:

interface ICar
{
    int Year { get; set; }
}

Kelas implementasi dapat menggunakan properti otomatis untuk menyederhanakan implementasi, jika tidak ada logika khusus yang terkait dengan properti:

class Automobile : ICar
{
    public int Year { get; set; } // automatically implemented
}

Nyatakan sebagai properti:

interface ICar {
   int Year { get; set; }
}

Eric Lippert memakukannya, saya akan menggunakan cara yang berbeda untuk mengatakan apa yang dia katakan. Semua anggota antarmuka adalah virtual dan mereka semua harus ditimpa oleh kelas yang mewarisi antarmuka. Anda tidak secara eksplisit menulis kata kunci virtual dalam deklarasi antarmuka, atau menggunakan kata kunci override di kelas, mereka tersirat.

Kata kunci virtual diimplementasikan dalam .NET dengan metode dan apa yang disebut v-table, sebuah array dari pointer metode. Kata kunci override mengisi slot v-table dengan pointer metode yang berbeda, menimpa yang diproduksi oleh kelas dasar. Properti, acara, dan pengindeks diimplementasikan sebagai metode di bawah tenda. Tapi ladang tidak. Antarmuka karena itu tidak dapat berisi bidang.

Mengapa tidak hanya memiliki Yearproperti, yang tidak apa-apa?

Antarmuka tidak berisi bidang karena bidang mewakili implementasi representasi data yang spesifik, dan mengeksposnya akan memecah enkapsulasi. Dengan demikian memiliki antarmuka dengan bidang secara efektif akan menjadi pengkodean untuk implementasi, bukan antarmuka, yang merupakan paradoks penasaran untuk memiliki antarmuka!

Misalnya, bagian dari Yearspesifikasi Anda mungkin mengharuskan ICarpelaksana tidak valid untuk mengizinkan penugasan Yearyang lebih lambat dari tahun berjalan +1 atau sebelum 1900. Tidak ada cara untuk mengatakan bahwa jika Anda telah membuka Yearbidang - jauh lebih baik menggunakan properti bukan untuk melakukan pekerjaan di sini.

Jawaban singkatnya adalah ya, setiap jenis implementasi harus membuat variabel pendukungnya sendiri. Ini karena antarmuka analog dengan kontrak. Yang dapat dilakukan hanyalah menentukan bagian kode yang dapat diakses publik yang harus tersedia oleh suatu tipe implementasi; itu tidak dapat berisi kode apa pun itu sendiri.

Pertimbangkan skenario ini menggunakan apa yang Anda sarankan:

public interface InterfaceOne
{
    int myBackingVariable;

    int MyProperty { get { return myBackingVariable; } }
}

public interface InterfaceTwo
{
    int myBackingVariable;

    int MyProperty { get { return myBackingVariable; } }
}

public class MyClass : InterfaceOne, InterfaceTwo { }

Kami memiliki beberapa masalah di sini:

• Karena semua anggota antarmuka - menurut definisi - publik, variabel pendukung kami sekarang terpapar kepada siapa saja yang menggunakan antarmuka
• Yang myBackingVariableakan MyClassdigunakan?

Pendekatan yang paling umum diambil adalah dengan mendeklarasikan antarmuka dan kelas abstrak barebones yang mengimplementasikannya. Ini memungkinkan Anda fleksibilitas untuk mewarisi dari kelas abstrak dan mendapatkan implementasi secara gratis, atau secara eksplisit mengimplementasikan antarmuka dan diizinkan untuk mewarisi dari kelas lain. Ini berfungsi seperti ini:

public interface IMyInterface
{
    int MyProperty { get; set; }
}

public abstract class MyInterfaceBase : IMyInterface
{
    int myProperty;

    public int MyProperty
    {
        get { return myProperty; }
        set { myProperty = value; }
    }
}

Orang lain telah memberikan 'Mengapa', jadi saya hanya akan menambahkan bahwa antarmuka Anda dapat mendefinisikan Kontrol; jika Anda membungkusnya di properti:

public interface IView {
    Control Year { get; }
}


public Form : IView {
    public Control Year { get { return uxYear; } } //numeric text box or whatever
}

Antarmuka tidak mengandung implementasi apa pun.

1. Tentukan antarmuka dengan properti.
2. Selanjutnya Anda dapat mengimplementasikan antarmuka itu di kelas apa pun dan menggunakan kelas ini untuk maju.
3. Jika diperlukan Anda dapat memiliki properti ini didefinisikan sebagai virtual di kelas sehingga Anda dapat mengubah perilakunya.

Banyak yang sudah dikatakan, tetapi untuk membuatnya sederhana, ini pendapat saya. Antarmuka dimaksudkan untuk memiliki kontrak metode yang akan dilaksanakan oleh konsumen atau kelas dan tidak memiliki bidang untuk menyimpan nilai.

Anda mungkin berpendapat bahwa mengapa properti diperbolehkan? Jadi jawaban sederhananya adalah - properti didefinisikan secara internal sebagai metode saja.

Untuk ini, Anda dapat memiliki kelas dasar Mobil yang mengimplementasikan bidang tahun, dan semua implementasi lainnya dapat mewarisinya.

Antarmuka mendefinisikan properti instance publik dan metode. Bidang biasanya bersifat pribadi, atau paling banyak dilindungi, internal, atau internal terlindungi (istilah "bidang" biasanya tidak digunakan untuk apa pun yang publik).

Seperti yang dinyatakan oleh balasan lain Anda dapat mendefinisikan kelas dasar dan mendefinisikan properti yang dilindungi yang akan dapat diakses oleh semua pewaris.

Satu keanehan adalah bahwa suatu antarmuka sebenarnya dapat didefinisikan sebagai internal tetapi membatasi kegunaan antarmuka, dan biasanya digunakan untuk mendefinisikan fungsionalitas internal yang tidak digunakan oleh kode eksternal lainnya.