Bagaimana tidak menggunakan antarmuka di C #

Saat mendesain aplikasi, Anda sering kali perlu menggunakan antarmuka dan kelas abstrak. Artikel ini membahas beberapa contoh umum "penyalahgunaan antarmuka" dan strategi yang dapat kami gunakan untuk menghindarinya. Ini juga membahas apa yang dimaksud dengan prinsip, "program ke antarmuka dan bukan ke implementasi."

Apa antarmuka?

Pertama, mari kita pahami antarmuka dan mengapa mereka dibutuhkan dalam pemrograman. Antarmuka hanyalah sebuah kontrak; itu tidak memiliki implementasi apapun. Antarmuka hanya berisi deklarasi anggota. Anda dapat memiliki deklarasi metode tetapi tidak definisi. Anggota yang dideklarasikan dalam antarmuka harus diimplementasikan dalam tipe (kelas dan struct) yang memperluas atau mengimplementasikan antarmuka. Antarmuka tidak boleh berisi bidang. Antarmuka tidak dapat diserialkan karena tidak dapat memiliki anggota data. Seperti yang saya katakan, sebuah antarmuka hanya dapat memiliki deklarasi dan bukan definisi.  

Hindari melakukan perubahan pada antarmuka 

Kelas atau struct yang memperluas antarmuka harus mengimplementasikan semua anggotanya. Jika penerapannya berubah, kode Anda akan tetap berfungsi. Namun, jika kontrak, misalnya antarmuka, berubah, maka Anda harus mengubah implementasi semua jenis yang memperluas antarmuka. Dengan kata lain, perubahan apa pun pada antarmuka akan memengaruhi semua jenis yang memperluas antarmuka. Jenis yang memperluas antarmuka harus mematuhi kontrak. Jadi, gunakan antarmuka hanya jika Anda jarang perlu mengubahnya. Selain itu, biasanya lebih baik membuat antarmuka baru daripada mengubah yang sudah ada. 

Program ke antarmuka, bukan ke implementasi

Anda mungkin pernah mendengar kata-kata "program ke antarmuka dan bukan ke implementasi" sekarang dan nanti. Anda mungkin telah menggunakan antarmuka dalam kode Anda, tetapi Anda masih memprogram untuk implementasi. Sekarang mari kita periksa perbedaan antara kedua pendekatan tersebut.

Saat Anda memprogram ke antarmuka, Anda menggunakan abstraksi paling umum (antarmuka atau kelas abstrak) daripada implementasi konkret. Karena antarmuka menjamin keseragaman, pemrograman ke antarmuka menyiratkan bahwa Anda dapat menangani objek serupa dengan cara yang seragam. Dengan melakukan itu, Anda dipisahkan dari penerapan - yaitu, penerapan Anda dapat bervariasi. Ini juga menambah fleksibilitas pada desain Anda.

Potongan kode berikut mengilustrasikan pemrograman ke sebuah antarmuka. Pertimbangkan antarmuka bernama IRepository yang berisi deklarasi beberapa metode. Kelas ProductRepository dan CustomerRepository memperluas antarmuka IRepository dan mengimplementasikan metode yang dideklarasikan dalam antarmuka IRepository, seperti yang ditunjukkan di bawah ini.

public interface IRepository

    {

        // Beberapa kode

    }

    kelas publik ProductRepository: IRepository

    {

        // Beberapa kode

    }

    public class CustomerRepository: IRepository

    {

        // Beberapa kode

    }

Kode berikut dapat digunakan untuk membuat instance dari ProductRepository.

Repositori IRepositori = ProductRepository baru ();

Idenya adalah Anda dapat menggunakan kelas apa pun di sini yang mengimplementasikan antarmuka IRepository. Jadi, pernyataan berikut juga valid.

IRepository repository = new CustomerRepository ();

Saat Anda memprogram implementasi, keseragaman ini hilang. Sebaliknya, Anda biasanya akan memiliki beberapa konstruksi, seperti pernyataan "if..else" atau "switch..case", untuk mengontrol perilaku dalam kode Anda.

Hindari penggunaan antarmuka yang berlebihan

Mengaitkan setiap kelas dengan sebuah antarmuka bukanlah praktik yang baik. Penggunaan antarmuka yang berlebihan dengan cara ini menciptakan kompleksitas yang tidak perlu, menyebabkan redundansi kode, melanggar YAGNI, dan mengurangi keterbacaan dan pemeliharaan basis kode. Antarmuka digunakan untuk mengelompokkan objek yang memiliki perilaku identik. Jika objek tidak memiliki perilaku yang sama, pengelompokan ini tidak diperlukan. Menggunakan antarmuka saat Anda tidak akan memiliki banyak implementasi adalah contoh penggunaan antarmuka yang berlebihan.

Membuat antarmuka untuk kelas yang cocok dengan anggota publik kelas cukup umum. Dengan demikian, Anda tidak menambahkan nilai sama sekali - Anda hanya menduplikasi antarmuka kelas tanpa menambahkan abstraksi nyata apa pun.

Sekarang mari kita lihat contoh bagaimana antarmuka digunakan secara berlebihan. Pertimbangkan antarmuka berikut bernama IProduct.

produk antarmuka publik

    {

        int Id {get; set; }

        string ProductName {get; set; }

        double Price {get; set; }

        int Kuantitas {get; set; }

    }

Kelas Produk memperluas antarmuka IProduct seperti yang ditunjukkan di bawah ini.

kelas publik Produk: Produk IP

    {

        public int Id {get; set; }

        string publik ProductName {get; set; }

        Harga ganda publik {get; set; }

        Kuantitas publik int {get; set; }

    }

Jelasnya, kita tidak membutuhkan antarmuka IProduct, karena antarmuka dan implementasinya identik. Kode redundan tidak diperlukan.

Mari kita lihat contoh lainnya. Potongan kode berikut menunjukkan antarmuka bernama IProductManager yang memiliki deklarasi dua metode, yaitu Simpan dan Perbarui.

 antarmuka publik IProductManager

    {

        void Save (produk IProduct);

        void Update (produk IProduct);

    }

Antarmuka IProductManager berisi deklarasi metode publik dari kelas ProductManager. Inilah tampilan kelas ProductManager.

 kelas publik ProductManager: IProductManager

    {

        public void Save (produk IProduct)

        {

           // Tulis implementasi Anda di sini

        }

        Pembaruan public void (produk IProduct)

        {

            // Tulis implementasi Anda di sini

        }

    }

Antarmuka IProduct dan IProductManager adalah contoh antarmuka yang terlalu sering digunakan. Kedua antarmuka ini memiliki implementasi tunggal dan tidak menambahkan nilai apa pun.

Dengan menggunakan antarmuka, Anda dapat menghapus penggandengan yang tidak perlu dalam kode Anda dan membuat kode Anda mudah diuji. Namun, penggunaan antarmuka yang berlebihan harus dihindari. Gunakan antarmuka hanya jika akan ada lebih dari satu penerapannya. Anda juga dapat menggunakan antarmuka saat Anda memiliki kelas yang memiliki banyak peran untuk dimainkan atau yang memiliki banyak tanggung jawab. Dalam hal ini kelas Anda dapat mengimplementasikan beberapa antarmuka - satu untuk setiap peran.