Bagaimanakah Kami Boleh Menguruskan Kebergantungan dengan Berkesan dalam Corak Kaedah Kilang dengan DI/IoC?

Corak Kaedah Kilang: Menangani Cabaran Pengurusan Kebergantungan dengan DI/IoC

Corak Kaedah Kilang, dipertingkatkan oleh Suntikan Ketergantungan (DI) dan Inversi Kawalan (IoC), menawarkan abstraksi yang elegan untuk penciptaan objek. Walau bagaimanapun, menguruskan banyak kebergantungan dalam pembina kilang boleh menjadi masalah. Artikel ini meneroka penyelesaian kepada cabaran biasa ini.

Masalahnya: Pembina Kilang Terlalu Kompleks

A CarFactory dengan pembina yang memerlukan banyak kebergantungan menunjukkan isu ini. Reka bentuk ini bercanggah dengan matlamat Kaedah Kilang untuk merangkum logik penciptaan dan mengasingkannya daripada butiran pergantungan. Menyuntik setiap pergantungan secara manual menjadi sukar apabila pelbagai jenis kereta semakin berkembang.

Penyelesaian: Pendekatan Diperhalusi

Dua pendekatan utama menawarkan pengurusan pergantungan yang lebih baik:

Pendekatan 1: Suntikan Bekas

Ini memudahkan pembina kilang dengan menyuntik bekas perkhidmatan yang bertanggungjawab untuk menyelesaikan kebergantungan secara dinamik. Ini mengurangkan kebergantungan langsung kilang:

<code class="language-csharp">public class CarFactory
{
    private readonly IContainer _container;

    public CarFactory(IContainer container)
    {
        _container = container;
    }

    public ICar CreateCar(Type type)
    {
        // Resolve dependencies via the container
        switch (type)
        {
            case Type a:
                return _container.Resolve<ICar1>();
            case Type b:
                return _container.Resolve<ICar2>();
            default:
                throw new ArgumentException("Unsupported car type.");
        }
    }
}</code>

Walaupun berkesan, pendekatan ini memperkenalkan pergantungan pada pencari perkhidmatan.

Pendekatan 2: Corak Strategi – Penyelesaian yang Lebih Elegan

Corak Strategi menawarkan penyelesaian unggul dengan memisahkan antara muka kilang daripada pelaksanaannya. Ini membolehkan pendaftaran berbilang kilang dan memilihnya secara dinamik berdasarkan jenis objek:

Antaramuka:

<code class="language-csharp">public interface ICarFactory
{
    ICar CreateCar();
    bool AppliesTo(Type type);
}

public interface ICarStrategy
{
    ICar CreateCar(Type type);
}</code>

Kilang Konkrit (Contoh):

<code class="language-csharp">public class Car1Factory : ICarFactory
{
    // Dependencies injected into the factory
    public Car1Factory(IDep1 dep1, IDep2 dep2, IDep3 dep3) { ... }
    public ICar CreateCar() { ... }
    public bool AppliesTo(Type type) { ... }
}

public class Car2Factory : ICarFactory { ... }</code>

Strategi:

<code class="language-csharp">public class CarStrategy : ICarStrategy
{
    private readonly ICarFactory[] _carFactories;

    public CarStrategy(ICarFactory[] carFactories)
    {
        _carFactories = carFactories;
    }

    public ICar CreateCar(Type type)
    {
        var factory = _carFactories.FirstOrDefault(f => f.AppliesTo(type));
        if (factory == null)
            throw new InvalidOperationException("No factory registered for type " + type);
        return factory.CreateCar();
    }
}</code>

Penggunaan:

<code class="language-csharp">var strategy = new CarStrategy(new ICarFactory[] {
    new Car1Factory(dep1, dep2, dep3),
    new Car2Factory(dep4, dep5, dep6)
});

var car1 = strategy.CreateCar(typeof(Car1));
var car2 = strategy.CreateCar(typeof(Car2));</code>

Pendekatan ini memberikan fleksibiliti dan kebolehlanjutan, membolehkan pendaftaran kilang baharu dengan mudah dan penciptaan objek diperkemas. Ia secara berkesan memisahkan logik penciptaan daripada kebergantungan, memudahkan pembangunan dan penyelenggaraan perhubungan yang kompleks.

Atas ialah kandungan terperinci Bagaimanakah Kami Boleh Menguruskan Kebergantungan dengan Berkesan dalam Corak Kaedah Kilang dengan DI/IoC?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!