解决温莎城堡中的循环依赖答案

【问题标题】：Solving a circular dependency in Castle Windsor解决温莎城堡中的循环依赖
【发布时间】：2015-07-29 07:09:07
【问题描述】：

目前我们在 Castle Windor（或任何 ioc 容器）中遇到循环依赖。我们有：

public class MessageHandler : IMessageHandler
{
    private readonly IService service;

    public MessageHandler(IService service)
    {
        this.service = service;
    }

    private void OnIncommingMessage(string message)
    {
        service.DoWork(message);
    }

    public void SendMessage(string message)
    {
        //sendMessage code
    }
}

public class Service : IService
{
    private readonly IMessageHandler messageHandler;

    public Service(IMessageHandler messageHandler)
    {
        this.messageHandler = messageHandler;
    }

    public void DoWork(string work)
    {
        //Do Work
    }

    private void SomeMethodNeedsToPushData(string message)
    {
        messageHandler.SendMessage(message);
    }

}

public interface IService
{
    void DoWork(string work);
}

public interface IMessageHandler
{
    void SendMessage(string message);
}

温莎城堡有没有解决上述问题的干净方法？我不喜欢通过属性注入，因为两个类都依赖于另一个，所以我认为这应该总是通过构造函数注入。

【问题讨论】：

反问：如果你不使用 IoC 容器，你会如何解决这个问题？
问题在于你的设计。不要试图通过转移到属性注入来打破循环，因为依赖循环仍然存在。一个常见的解决方案是引入一个 IMessageHandler 和 IService 都可以依赖的新类。
查看答案here - 注册Func<YourType> 而不是YourType。 PS：删除重复问题

标签： c# dependency-injection castle-windsor

【解决方案1】：

我相信问题出在您的课程设计上。认为您可以通过引入可观察模式来解决循环依赖问题。

public interface IService : IDisposable
{
    void Serve(string message);
}

public interface IMessageHandler : IService
{
}

public class MessageHandler : IMessageHandler
{
    private readonly IWorkDispatcher workDispatcher;

    public MessageHandler (IServicesRegistry servicesRegistry)
    {
        servicesRegistry.RegisterService(WorkType.MessageHandler, this);
        this.servicesRegistry = servicesRegistry;
    }
    private void OnIncommingMessage(string message)
    {
        servicesRegistry.SendMessage(WorkType.Service, message);
    }

    public void Serve(string message) // was SendMessage(string message)
    {
        //sendMessage code
    }

    public void Dispose()
    {
        servicesRegistry.RemoveService(this);
    }
}

public interface IWorkerService : IService
{
}

public class WorkerService: IWorkerService 
{
    private readonly IServicesRegistry servicesRegistry

    public Service(IServicesRegistry servicesRegistry)
    {
        servicesRegistry.RegisterService(WorkType.Worker, this);
        this.servicesRegistry = servicesRegistry;
    }

    public void Serve(string message); // was DoWork(string work)
    {
        //Do Work
    }

    private void SomeMethodNeedsToPushData(string message)
    {
        servicesRegistry.SendMessage(WorkType.MessageHandler, message);
    }

    public void Dispose()
    {
        servicesRegistry.RemoveService(this);
    }
}

public enum WorkType
{
    Service,
    MessageHandler
}

public interface IServicesRegistry
{
    void RegisterService(WorkType workType, IService service);
    void RemoveService(IService service);
    void QueueWork(WorkType workType, string message);
}

【讨论】：