Làm thế nào để sử dụng tiêm phụ thuộc và tránh khớp nối thời gian?

Giả sử tôi có các Servicephụ thuộc nhận thông qua hàm tạo nhưng cũng cần được khởi tạo với dữ liệu tùy chỉnh (ngữ cảnh) trước khi có thể sử dụng:

public interface IService
{
    void Initialize(Context context);
    void DoSomething();
    void DoOtherThing();
}

public class Service : IService
{
    private readonly object dependency1;
    private readonly object dependency2;
    private readonly object dependency3;

    public Service(
        object dependency1,
        object dependency2,
        object dependency3)
    {
        this.dependency1 = dependency1 ?? throw new ArgumentNullException(nameof(dependency1));
        this.dependency2 = dependency2 ?? throw new ArgumentNullException(nameof(dependency2));
        this.dependency3 = dependency3 ?? throw new ArgumentNullException(nameof(dependency3));
    }

    public void Initialize(Context context)
    {
        // Initialize state based on context
        // Heavy, long running operation
    }

    public void DoSomething()
    {
        // ...
    }

    public void DoOtherThing()
    {
        // ...
    }
}

public class Context
{
    public int Value1;
    public string Value2;
    public string Value3;
}

Bây giờ - dữ liệu ngữ cảnh không được biết trước nên tôi không thể đăng ký dưới dạng phụ thuộc và sử dụng DI để đưa dữ liệu vào dịch vụ

Đây là ví dụ khách hàng trông như thế nào:

public class Client
{
    private readonly IService service;

    public Client(IService service)
    {
        this.service = service ?? throw new ArgumentNullException(nameof(service));
    }

    public void OnStartup()
    {
        service.Initialize(new Context
        {
            Value1 = 123,
            Value2 = "my data",
            Value3 = "abcd"
        });
    }

    public void Execute()
    {
        service.DoSomething();
        service.DoOtherThing();
    }
}

Như bạn có thể thấy - có khớp nối tạm thời và khởi tạo mã phương thức có liên quan, bởi vì trước tiên tôi cần gọi service.Initializeđể có thể gọi service.DoSomethingvà service.DoOtherThingsau đó.

Các phương pháp khác mà tôi có thể loại bỏ những vấn đề này là gì?

Làm rõ thêm về hành vi:

Mỗi phiên bản của máy khách cần có phiên bản riêng của dịch vụ được khởi tạo với dữ liệu ngữ cảnh cụ thể của máy khách. Vì vậy, dữ liệu ngữ cảnh đó không phải là tĩnh hoặc được biết trước vì vậy nó không thể được DI đưa vào trong hàm tạo.

Có một số cách để giải quyết vấn đề khởi tạo:

• Như đã trả lời trong /software//a/334994/301401 , các phương thức init () là một mùi mã. Khởi tạo một đối tượng là trách nhiệm của nhà xây dựng - đó là lý do tại sao chúng ta có các nhà xây dựng.
• Thêm Dịch vụ đã cho phải được khởi tạo vào nhận xét doc của hàm Clienttạo và để cho hàm tạo ném nếu dịch vụ không được khởi tạo. Điều này chuyển trách nhiệm cho người cung cấp cho bạn IServiceđối tượng.

Tuy nhiên, trong ví dụ của bạn, Clientlà người duy nhất biết các giá trị được truyền vào Initialize(). Nếu bạn muốn giữ nó theo cách đó, tôi đề nghị như sau:

• Thêm một IServiceFactoryvà chuyển nó cho các nhà Clientxây dựng. Sau đó, bạn có thể gọi serviceFactory.createService(new Context(...))cho bạn một khởi tạo IServicecó thể được sử dụng bởi khách hàng của bạn.

Các nhà máy có thể rất đơn giản và cũng cho phép bạn tránh các phương thức init () và sử dụng các hàm tạo thay thế:

public interface IServiceFactory
{
    IService createService(Context context);
}

public class ServiceFactory : IServiceFactory
{
    public Service createService(Context context)
    {
        return new Service(context);
    }
}

Trong máy khách, OnStartup()cũng là một phương thức khởi tạo (nó chỉ sử dụng một tên khác). Vì vậy, nếu có thể (nếu bạn biết Contextdữ liệu), nhà máy nên được gọi trực tiếp trong hàm Clienttạo. Nếu điều đó là không thể, bạn cần lưu trữ IServiceFactoryvà gọi nó vào OnStartup().

Khi Servicecó phụ thuộc không được cung cấp bởi Clienthọ sẽ được DI cung cấp thông qua ServiceFactory:

public interface IServiceFactory
{
    IService createService(Context context);
}    

public class ServiceFactory : IServiceFactory
{        
    private readonly object dependency1;
    private readonly object dependency2;
    private readonly object dependency3;

    public ServiceFactory(object dependency1, object dependency2, object dependency3)
    {
        this.dependency1 = dependency1;
        this.dependency2 = dependency2;
        this.dependency3 = dependency3;
    }

    public Service createService(Context context)
    {
        return new Service(context, dependency1, dependency2, dependency3);
    }
}

Các Initializephương pháp nên được loại bỏ khỏi IServicegiao diện, vì đây là một chi tiết thực hiện. Thay vào đó, hãy định nghĩa một lớp khác lấy ví dụ cụ thể của Dịch vụ và gọi phương thức khởi tạo trên nó. Sau đó, lớp mới này thực hiện giao diện IService:

public class ContextDependentService : IService
{
    public ContextDependentService(Context context, Service service)
    {
        this.service = service;

        service.Initialize(context);
    }

    // Methods in the IService interface
}

Điều này giữ cho mã máy khách không biết gì về thủ tục khởi tạo, trừ trường hợp ContextDependentServicelớp được khởi tạo. Bạn ít nhất giới hạn các phần trong ứng dụng của bạn cần biết về thủ tục khởi tạo mạnh mẽ này.

Dường như với tôi rằng bạn có hai lựa chọn ở đây

1. Di chuyển mã Khởi tạo vào Ngữ cảnh và đưa vào Bối cảnh khởi tạo

ví dụ.

public InitialisedContext Initialise()

2. Có cuộc gọi đầu tiên để Thực hiện cuộc gọi Khởi tạo nếu cuộc gọi chưa hoàn tất

ví dụ.

public async Task Execute()
{
     //lock context
     //check context is not initialised
     // init if required
     //execute code...
}

3. Chỉ cần ném ngoại lệ nếu Ngữ cảnh không được khởi chạy khi bạn gọi Execute. Giống như SqlConnection.

Tiêm một nhà máy là tốt nếu bạn chỉ muốn tránh bối cảnh như một tham số. Chỉ nói việc triển khai cụ thể này cần một ngữ cảnh và bạn không muốn thêm nó vào Giao diện

Nhưng về cơ bản, bạn có cùng một vấn đề, nếu nhà máy chưa có bối cảnh khởi tạo.

Bạn không nên phụ thuộc giao diện của mình vào bất kỳ bối cảnh db và khởi tạo phương thức nào. Bạn có thể làm điều đó trong lớp xây dựng cụ thể.

public interface IService
{
    void DoSomething();
    void DoOtherThing();
}

public class Service : IService
{
    private readonly object dependency1;
    private readonly object dependency2;
    private readonly object dependency3;
    private readonly object context;

    public Service(
        object dependency1,
        object dependency2,
        object dependency3,
        object context )
    {
        this.dependency1 = dependency1 ?? throw new ArgumentNullException(nameof(dependency1));
        this.dependency2 = dependency2 ?? throw new ArgumentNullException(nameof(dependency2));
        this.dependency3 = dependency3 ?? throw new ArgumentNullException(nameof(dependency3));

        // context is concrete class details not interfaces.
        this.context = context;

        // call init here constructor.
        this.Initialize(context);
    }

    protected void Initialize(Context context)
    {
        // Initialize state based on context
        // Heavy, long running operation
    }

    public void DoSomething()
    {
        // ...
    }

    public void DoOtherThing()
    {
        // ...
    }
}

Và, một câu trả lời cho câu hỏi chính của bạn sẽ là Thuộc tính tiêm .

public class Service
    {
        public Service(Context context)
        {
            this.context = context;
        }

        private Dependency1 _dependency1;
        public Dependency1 Dependency1
        {
            get
            {
                if (_dependency1 == null)
                    _dependency1 = Container.Resolve<Dependency1>();

                return _dependency1;
            }
        }

        //...
    }

Bằng cách này, bạn có thể gọi tất cả các phụ thuộc bằng cách tiêm bất động sản . Nhưng nó có thể là con số khổng lồ. Nếu vậy, bạn có thể sử dụng Con Contortor tiêm cho chúng, nhưng bạn có thể đặt bối cảnh của mình theo thuộc tính bằng cách kiểm tra xem nó có rỗng không.

Misko Hevery có một bài đăng blog rất hữu ích về trường hợp bạn gặp phải. Cả hai cần newable và tiêm cho bạn Servicelớp và bài viết trên blog này có thể giúp bạn.