C# 解决Castle Windsor中的循环依赖

目前，我们在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);
}

---

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

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

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);
}

---

反问：如果你没有使用IoC容器，你会如何解决这个问题？问题在于你的设计。不要试图通过转移到属性注入来打破这个循环，因为依赖性循环仍然存在。一个常见的解决方案是引入一个IMessageHandler和iSeries都可以依赖的新类。请参见答案-register

Func

，而不是

YourType

。附注：删除重复问题