Prinsip Ketergantungan Pembalikan vs "Program ke antarmuka, bukan implementasi"

Saya mencoba memahami bagaimana Prinsip Ketergantungan Inversi berbeda dari prinsip "program ke antarmuka, bukan implementasi".

Saya mengerti apa artinya "Program ke antarmuka, bukan implementasi". Saya juga mengerti bagaimana ini memungkinkan desain yang lebih fleksibel dan dirawat.

Tapi saya tidak mengerti bagaimana Prinsip Ketergantungan Inversi berbeda dari prinsip "Program ke antarmuka, bukan implementasi".

Saya membaca tentang DIP di beberapa tempat di web, dan itu tidak menghilangkan kebingungan saya. Saya masih tidak melihat bagaimana kedua prinsip itu berbeda satu sama lain. Terima kasih atas bantuan Anda.

"Program ke antarmuka" berarti tidak bergantung pada tipe konkret untuk melakukan pekerjaan Anda , tetapi itu tidak menentukan bagaimana Anda harus mendapatkan ketergantungan Anda.

"Prinsip Inversi Ketergantungan" mengatakan bahwa suatu objek tidak boleh mengendalikan penciptaan ketergantungannya, itu hanya harus mengiklankan ketergantungan apa yang dibutuhkannya dan membiarkan penelepon menyediakannya . Tapi itu tidak menentukan apakah ketergantungan harus berupa tipe konkret atau antarmuka.

Saya akan menggambarkan perbedaan dengan beberapa kode C #.

Contoh berikut ini tergantung pada jenis beton, dan itu mengontrol penciptaan ketergantungan itu sendiri. Ini tidak mengikuti "program ke antarmuka" atau "inversi ketergantungan":

public class ThingProcessor
{
    MyThing _myThing;

    public ThingProcessor()
    {
        _myThing = new MyThing();
    }

    public void DoSomething()
    {
        _myThing.DoIt();
    }
}

Contoh berikut bergantung pada antarmuka, tetapi ia mengontrol kreasi ketergantungannya sendiri. Ini mengikuti "program ke antarmuka", tetapi bukan "inversi ketergantungan":

public class ThingProcessor
{
    IMyThing _myThing;

    public ThingProcessor()
    {
        _myThing = ThingFactory.GiveMeANewMyThing();
    }

    public void DoSomething()
    {
        _myThing.DoIt();
    }
}

Contoh berikut tergantung pada jenis beton, tetapi meminta ketergantungannya untuk dibuat dan diteruskan ke sana. Ini mengikuti "inversi ketergantungan", tetapi bukan "program ke antarmuka":

public class ThingProcessor
{
    MyThing _myThing;

    public ThingProcessor(MyThing myThing)
    {
        _myThing = myThing;
    }

    public void DoSomething()
    {
        _myThing.DoIt();
    }
}

Contoh berikut bergantung pada antarmuka, dan ia meminta ketergantungannya untuk dibuat dan diteruskan ke sana. Ini mengikuti "inversi ketergantungan" dan "program ke antarmuka":

public class ThingProcessor
{
    IMyThing _myThing;

    public ThingProcessor(IMyThing myThing) // using an interface
    {
        _myThing = myThing;
    }

    public void DoSomething()
    {
        _myThing.DoIt();
    }
}

Mereka umumnya hal yang sama. Jika Anda membaca Apa Prinsip Ketergantungan Pembalikan dan mengapa itu penting? dan Prinsip Ketergantungan Pembalikan , Anda akan menyadari dua "prinsip" pada dasarnya berbicara tentang hal yang sama.

• Modul tingkat tinggi tidak boleh bergantung pada modul tingkat rendah. Keduanya harus bergantung pada abstraksi.
• Abstraksi tidak boleh bergantung pada detail. Detail harus bergantung pada abstraksi.

Antarmuka adalah abstraksi dan implementasi adalah detail. Jika Anda menggantikannya dalam dua pernyataan sebelumnya, pada dasarnya Anda mendapatkan "kode harus bergantung pada antarmuka dan bukan implementasi". Dan itu kedengarannya sama bagi saya.

Antarmuka adalah salah satu cara untuk mengimplementasikan DI. Jika Anda menentukan antarmuka sebagai parameter dalam metode konstruktor suatu kelas, Anda bisa memberikan objek apa pun yang Anda suka ke metode konstruktor tersebut, asalkan objek itu mengimplementasikan antarmuka parameter konstruktor.

Dengan kata lain, pemrograman antarmuka memungkinkan Anda mengubah implementasi antarmuka itu. Begitulah cara kami dapat mengganti objek tiruan dengan objek nyata selama pengujian unit, menentukan penyedia data yang berbeda, dan sebagainya.