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

12

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.

design object-oriented principles Aviv Cohn
sumber

Jawaban:

25

"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();
    }
}
Eric King
sumber
1
Ilustrasi perbedaan yang sangat baik.
Rory Hunter
8
Apa yang Anda bicarakan adalah injeksi tangguh. Dan inversi ketergantungan dan injeksi ketergantungan adalah dua hal yang berbeda.
Euforia
1
@ Euphoric Saya berbicara tentang Prinsip Ketergantungan Inversi, yang merupakan konsep abstrak, dengan menggunakan Injeksi Ketergantungan sebagai contoh implementasi konkret. Saya mengerti perbedaannya.
Eric King
1
@EricKing Maka Anda harus secara eksplisit mengatakan bahwa dalam jawaban Anda alih-alih pergi "The" Prinsip Ketergantungan Pembalikan "mengatakan ..." yang jelas salah jika Anda membaca jawaban saya.
Euforia
1
Saya setuju dengan Euforia. Prinsip Ketergantungan Inversi mengatakan bahwa lapisan kode tingkat yang lebih tinggi harus bergantung pada potongan kode tingkat yang lebih rendah, bukan sebaliknya. Misalnya PrintStreamharus bergantung pada antarmuka yang dibuat oleh ByteOutputStream. Ketergantungan Injeksi tidak menyebutkan tentang siapa yang harus bergantung pada siapa.
Doval
5

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.

Euforia
sumber
Ini harus menjadi jawaban yang diterima, jawaban yang paling banyak
dipilihnya
2

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.

Robert Harvey
sumber