Bagaimana menghindari Ketergantungan konstruktor kegilaan?

Saya menemukan bahwa konstruktor saya mulai terlihat seperti ini:

public MyClass(Container con, SomeClass1 obj1, SomeClass2, obj2.... )

dengan daftar parameter yang semakin meningkat. Karena "Kontainer" adalah wadah injeksi ketergantungan saya, mengapa saya tidak bisa melakukan ini saja:

public MyClass(Container con)

untuk setiap kelas? Apa kerugiannya? Jika saya melakukan ini, rasanya saya menggunakan statis yang dimuliakan. Silakan bagikan pemikiran Anda tentang kegilaan IoC dan Dependency Injection

Anda benar bahwa jika Anda menggunakan wadah sebagai Pencari Layanan, ini lebih atau kurang merupakan pabrik statis yang dimuliakan. Untuk banyak alasan saya menganggap ini sebagai anti-pola .

Salah satu manfaat luar biasa dari Injeksi Konstruktor adalah membuat pelanggaran terhadap Prinsip Tanggung Jawab Tunggal menjadi sangat jelas.

Ketika itu terjadi, saatnya untuk refactor ke Layanan Fasad . Singkatnya, buat antarmuka baru yang lebih berbutir kasar yang menyembunyikan interaksi antara beberapa atau semua dependensi berbutir halus yang saat ini Anda butuhkan.

Saya tidak berpikir konstruktor kelas Anda harus memiliki referensi ke periode kontainer IOC Anda. Ini mewakili ketergantungan yang tidak perlu antara kelas Anda dan wadah (jenis ketergantungan yang coba dihindari oleh IOC!).

Kesulitan melewati parameter tidak menjadi masalah. Masalahnya adalah kelas Anda melakukan terlalu banyak, dan harus dipecah lagi.

Ketergantungan Injeksi dapat bertindak sebagai peringatan dini untuk kelas yang terlalu besar, khususnya karena meningkatnya rasa sakit lulus di semua dependensi.

Saya menemukan pertanyaan serupa tentang Injeksi ketergantungan berbasis konstruktor dan betapa rumitnya untuk melewati semua dependensi.

Salah satu pendekatan, saya telah digunakan di masa lalu adalah dengan menggunakan pola fasad aplikasi menggunakan lapisan layanan. Ini akan memiliki API kasar. Jika layanan ini tergantung pada repositori, Ini akan menggunakan injeksi setter dari properti pribadi. Ini membutuhkan pembuatan pabrik abstrak dan memindahkan logika menciptakan repositori ke pabrik.

Kode lengkap dengan penjelasan dapat ditemukan di sini

Praktik terbaik untuk IoC di lapisan layanan yang kompleks

Saya membaca seluruh utas ini, dua kali, dan saya pikir orang merespons dengan apa yang mereka ketahui, bukan dengan apa yang diminta.

Pertanyaan asli JP terlihat seperti dia membangun objek dengan mengirimkan resolver, dan kemudian banyak kelas, tapi kami mengasumsikan bahwa kelas / objek itu sendiri adalah layanan, siap untuk injeksi. Bagaimana jika tidak?

JP, jika Anda ingin memanfaatkan DI dan menginginkan kemuliaan pencampuran injeksi dengan data kontekstual, tidak satu pun dari pola-pola ini (atau yang diduga "anti-pola") yang secara khusus mengatasinya. Itu sebenarnya bermuara pada menggunakan paket yang akan mendukung Anda dalam upaya seperti itu.

Container.GetSevice<MyClass>(someObject1, someObject2)

... format ini jarang didukung. Saya percaya kesulitan pemrograman dukungan seperti itu, ditambahkan ke kinerja menyedihkan yang akan dikaitkan dengan implementasi, membuatnya tidak menarik bagi pengembang opensource.

Tapi itu harus dilakukan, karena saya harus dapat membuat dan mendaftarkan pabrik untuk MyClass'es, dan pabrik itu harus dapat menerima data / input yang tidak didorong menjadi "layanan" hanya demi melewati data. Jika "anti-pola" adalah tentang konsekuensi negatif, maka memaksakan keberadaan jenis layanan buatan untuk meneruskan data / model tentu negatif (setara dengan perasaan Anda tentang membungkus kelas Anda ke dalam wadah. Naluri yang sama berlaku).

Ada beberapa kerangka kerja yang mungkin membantu, meskipun mereka terlihat agak jelek. Misalnya, Ninject:

Membuat instance menggunakan Ninject dengan parameter tambahan di konstruktor

Itu untuk .NET, populer, dan masih tidak bersih seperti seharusnya, tapi saya yakin ada sesuatu dalam bahasa apa pun yang Anda pilih untuk digunakan.

Menyuntikkan wadah adalah jalan pintas yang akhirnya akan Anda sesali.

Injeksi yang berlebihan bukan masalahnya, biasanya merupakan gejala dari kelemahan struktural lainnya, terutama pemisahan kekhawatiran. Ini bukan satu masalah tetapi dapat memiliki banyak sumber dan apa yang membuat ini sangat sulit untuk diperbaiki adalah bahwa Anda harus berurusan dengan semuanya, kadang-kadang pada saat yang sama (pikirkan untuk melepaskan spageti).

Berikut adalah daftar hal-hal yang tidak perlu diwaspadai

Desain Domain Buruk (Agregat root .... dll.)

Pemisahan keprihatinan yang buruk (Komposisi layanan, Perintah, pertanyaan) Lihat CQRS dan Event Sourcing.

ATAU Pemetaan (hati-hati, hal-hal ini dapat membawa Anda ke masalah)

Lihat Model dan DTO lainnya (Jangan pernah gunakan kembali, dan cobalah untuk meminimalkannya !!!!)

Masalah:

1) Konstruktor dengan daftar parameter yang semakin meningkat.

2) Jika kelas diwariskan (Contoh:) RepositoryBasemaka mengubah tanda tangan konstruktor menyebabkan perubahan dalam kelas turunan.

Solusi 1

Lulus IoC Containerke konstruktor

Mengapa

• Tidak ada lagi peningkatan daftar parameter
• Tanda tangan konstruktor menjadi sederhana

Kenapa tidak

• Membuat kelas Anda tergabung erat dengan wadah IoC. (Itu menyebabkan masalah ketika 1. Anda ingin menggunakan kelas itu dalam proyek lain di mana Anda menggunakan wadah IoC yang berbeda. 2. Anda memutuskan untuk mengubah wadah IoC)
• Membuat kelas Anda kurang deskriptif. (Anda tidak dapat benar-benar melihat konstruktor kelas dan mengatakan apa yang dibutuhkan untuk berfungsi.)
• Kelas dapat mengakses semua layanan yang berpotensi.

Solusi 2

Buat kelas yang mengelompokkan semua layanan dan meneruskannya ke konstruktor

 public abstract class EFRepositoryBase 
 {
    public class Dependency
    {
        public DbContext DbContext { get; }
        public IAuditFactory AuditFactory { get; }

         public Dependency(
            DbContext dbContext,
            IAuditFactory auditFactory)
        {
            DbContext = dbContext;
            AuditFactory = auditFactory;
        }
    }

    protected readonly DbContext DbContext;        
    protected readonly IJobariaAuditFactory auditFactory;

    protected EFRepositoryBase(Dependency dependency)
    {
        DbContext = dependency.DbContext;
        auditFactory= dependency.JobariaAuditFactory;
    }
  }

Kelas turunan

  public class ApplicationEfRepository : EFRepositoryBase      
  {
     public new class Dependency : EFRepositoryBase.Dependency
     {
         public IConcreteDependency ConcreteDependency { get; }

         public Dependency(
            DbContext dbContext,
            IAuditFactory auditFactory,
            IConcreteDependency concreteDependency)
        {
            DbContext = dbContext;
            AuditFactory = auditFactory;
            ConcreteDependency = concreteDependency;
        }
     }

      IConcreteDependency _concreteDependency;

      public ApplicationEfRepository(
          Dependency dependency)
          : base(dependency)
      { 
        _concreteDependency = dependency.ConcreteDependency;
      }
   }

Mengapa

• Menambahkan ketergantungan baru ke kelas tidak memengaruhi kelas turunan
• Kelas agnostik dari wadah IoC
• Kelas bersifat deskriptif (dalam aspek ketergantungannya). Dengan konvensi, jika Anda ingin tahu di mana kelas Abergantung, informasi itu diakumulasikanA.Dependency
• Tanda tangan konstruktor menjadi sederhana

Kenapa tidak

• perlu membuat kelas tambahan
• pendaftaran layanan menjadi rumit (Anda harus mendaftar X.Dependencysecara terpisah)
• Secara konseptual sama dengan passing IoC Container
• ..

Solusi 2 hanyalah mentah, jika ada argumen yang kuat menentangnya, maka komentar deskriptif akan dihargai

Ini adalah pendekatan yang saya gunakan

public class Hero
{

    [Inject]
    private IInventory Inventory { get; set; }

    [Inject]
    private IArmour Armour { get; set; }

    [Inject]
    protected IWeapon Weapon { get; set; }

    [Inject]
    private IAction Jump { get; set; }

    [Inject]
    private IInstanceProvider InstanceProvider { get; set; }


}

Berikut ini adalah pendekatan kasar bagaimana melakukan injeksi dan menjalankan konstruktor setelah menyuntikkan nilai. Ini adalah program yang berfungsi penuh.

public class InjectAttribute : Attribute
{

}


public class TestClass
{
    [Inject]
    private SomeDependency sd { get; set; }

    public TestClass()
    {
        Console.WriteLine("ctor");
        Console.WriteLine(sd);
    }
}

public class SomeDependency
{

}


class Program
{
    static void Main(string[] args)
    {
        object tc = FormatterServices.GetUninitializedObject(typeof(TestClass));

        // Get all properties with inject tag
        List<PropertyInfo> pi = typeof(TestClass)
            .GetProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public)
            .Where(info => info.GetCustomAttributes(typeof(InjectAttribute), false).Length > 0).ToList();

        // We now happen to know there's only one dependency so we take a shortcut just for the sake of this example and just set value to it without inspecting it
        pi[0].SetValue(tc, new SomeDependency(), null);


        // Find the right constructor and Invoke it. 
        ConstructorInfo ci = typeof(TestClass).GetConstructors()[0];
        ci.Invoke(tc, null);

    }
}

Saat ini saya sedang mengerjakan proyek hobi yang berfungsi seperti ini https://github.com/Jokine/ToolProject/tree/Core

Kerangka kerja injeksi ketergantungan apa yang Anda gunakan? Sudahkah Anda mencoba menggunakan injeksi berbasis setter saja?

Manfaat untuk injeksi berbasis konstruktor adalah terlihat alami untuk programmer Java yang tidak menggunakan kerangka kerja DI. Anda perlu 5 hal untuk menginisialisasi kelas maka Anda memiliki 5 argumen untuk konstruktor Anda. The downside adalah apa yang Anda perhatikan, itu menjadi sulit ketika Anda memiliki banyak ketergantungan.

Dengan Spring, Anda bisa meneruskan nilai yang diperlukan dengan setter dan Anda bisa menggunakan @required annotations untuk memastikan bahwa mereka disuntikkan. The downside adalah bahwa Anda perlu memindahkan kode inisialisasi dari konstruktor ke metode lain dan memiliki panggilan Spring yang setelah semua dependensi disuntikkan dengan menandainya dengan @PostConstruct. Saya tidak yakin tentang kerangka kerja lain tetapi saya menganggap mereka melakukan sesuatu yang serupa.

Kedua cara bekerja, ini masalah preferensi.