注册动态映射（或委托而不显式解析）

Question

在我的问题之前，我有以下注册：

container.Register<ISettings>();
container.Register<Connection1>();
container.Register<Connection2>();

Connection1和Connection2都实现了接口IConnection 。 为了简化我的情况ISettings只包含一个属性UseConnection1 。

我想要的是为服务类型IConnection注册一个映射或委托，它期望ISettings作为依赖项，并返回Connection1或Connection2作为其实现类型。

RegisterMapping本身没有这样的功能，因为不能使用任何依赖服务来动态指定映射。

另一方面， RegisterDelegate具有获取特定依赖服务的能力，但希望用户返回实现本身，而不是其类型，如下所示：

container.RegisterDelegate<ISettings, IResolver, IConnection>((settings, resolver) =>
{
    var serviceType = settings.UseConnection1 ? typeof(Connection1) : typeof(Connection2);
    return resolver.Resolve<IConnection>(serviceType);
});

正如所见，该实现将来自远非完美的IResolver ，如DryIoc wiki中所述。

我想做的是这样的：

container.RegisterSomething<IConnection>((ISettings settings) => settings.UseConnection1 ? typeof(Connection1) : typeof(Connection2));

DryIoc 有可能吗？

Answer 1

在对象构造期间使用运行时数据（即Settings.UseConnection1 ）会导致运行时数据 DI 代码异味，这是您应该努力防止的事情。 此外，两个依赖项的注入不应该带来任何性能问题，因为对象的创建应该是快速和可靠的，因为注入构造函数应该是简单的。

相反，请尝试使用代理，例如

public class ProxyConnection : IConnection
{
    private readonly ISettings Settings;
    private readonly Connection1 Con1;
    private readonly Connection2 Con2;

    public ProxyConnection(ISettings settings, Connection1 con1, Connection2 con2)
    {
        Settings = settings;
        Con1 = con1;
        Con2 = con2;
    }

    private IConnection Connection => Settings.UseConnection1 ? Con1 : Con2;

    // Implement IConnection methods here, e.g.
    void IConnection.Open() => Connection.Open();
}

// Or use C# 9 to do the same but with less code:
public record ProxyConnection(ISettings Settings, Connection1 Con1, Connection2 Con2)
    : IConnection
{
    private IConnection Connection => Settings.UseConnection1 ? Con1 : Con2;

    // Implement IConnection methods here, e.g.
    void IConnection.Open() => Connection.Open();
}

现在您可以按如下方式注册您的类型：

container.Register<ISettings>();
container.Register<Connection1>();
container.Register<Connection2>();
container.Register<IConnection, ProxyConnection>();

但是，如果Settings在应用程序启动时仅加载一次并且没有更改，则无需在运行时在实现之间切换，您可以将注册减少到以下内容：

if (settings.UseConnection1)
{
   container.Register<IConnection, Connection1>(); 
}
else
{
   container.Register<IConnection, Connection2>(); 
}

在这种情况下，不需要代理类。

Answer 2

首先，我同意@steven 的观点，即应该小心处理运行时数据，最好在 DI 之外解决。 特别是，如果它是可变的并且被用作条件。

其次，如果不可避免，我会使用评论中的工厂委托作为最不意外的解决方案： RegisterDelegate<ISettting, IConnection>(settings => /*connection construction*/) 。

最后，正面的答案是基于条件的解决方案，可以通过条件设置来完成：

实时代码

using System;
using DryIoc;
                    
public class Program
{
    public static void Main()
    {
        var container = new Container(); 
        container.Register<ISettings, Settings>(Reuse.Singleton);
        container.Register<IConnection, Connection1>(setup: Setup.With(condition: r => r.Container.Resolve<ISettings>().UseConnection1));
        container.Register<IConnection, Connection2>(setup: Setup.With(condition: r => r.Container.Resolve<ISettings>().UseConnection1 == false));
        
        var settings = container.Resolve<ISettings>();
        settings.UseConnection1 = true;
        var conn1 = container.Resolve<IConnection>();
        Console.WriteLine(conn1.GetType());
        
        settings.UseConnection1 = false;
        var conn2 = container.Resolve<IConnection>();
        Console.WriteLine(conn2.GetType());
    }
    
    public interface ISettings
    {
        bool UseConnection1 { get; set; }
    }
    
    public class Settings : ISettings { public bool UseConnection1 { get; set; } }

    public interface IConnection {}
    public class Connection1 : IConnection {}
    public class Connection2 : IConnection {}
}

更新：

还有另一种更接近您最初想象的选择：

container.Register<IConnection>(made: Made.Of(r =>
    r.Container.Resolve<ISettings>().UseConnection1 ? typeof(Connection1) : typeof(Connection2)));