保持简单。让插件依赖于构造函数注入，它的优点是构造函数静态宣布每个类的依赖项。然后使用"反射"来确定您可以创建的内容。

例如，假设您有三个服务：

public interface IFoo { }
public interface IBar { }
public interface IBaz { }

此外，假设存在三个插件：

public class Plugin1
{
    public readonly IFoo Foo;
    public Plugin1(IFoo foo)
    {
        this.Foo = foo;
    }
}
public class Plugin2
{
    public readonly IBar Bar;
    public readonly IBaz Baz;
    public Plugin2(IBar bar, IBaz baz)
    {
        this.Bar = bar;
        this.Baz = baz;
    }
}
public class Plugin3
{
    public readonly IBar Bar;
    public readonly IBaz Baz;
    public Plugin3(IBar bar)
    {
        this.Bar = bar;
    }
    public Plugin3(IBar bar, IBaz baz)
    {
        this.Bar = bar; ;
        this.Baz = baz;
    }
}

很明显，Plugin1需要IFoo，而Plugin2需要IBar和IBaz。第三个类 Plugin3 更特殊一些，因为它具有可选的依赖项。虽然它需要IBar，但如果可用，它也可以使用IBaz。

您可以定义一个 Composer，它使用一些基本反射来检查是否可以根据可用服务创建各种插件的实例：

public class Composer
{
    public readonly ISet<Type> services;
    public Composer(ISet<Type> services)
    {
        this.services = services;
    }
    public Composer(params Type[] services) :
        this(new HashSet<Type>(services))
    {
    }
    public IEnumerable<Type> GetAvailableClients(params Type[] candidates)
    {
        return candidates.Where(CanCreate);
    }
    private bool CanCreate(Type t)
    {
        return t.GetConstructors().Any(CanCreate);
    }
    private bool CanCreate(ConstructorInfo ctor)
    {
        return ctor.GetParameters().All(p => 
            this.services.Contains(p.ParameterType));
    }
}

如您所见，您可以使用一组可用服务配置Composer实例，然后可以使用候选项列表调用 GetAvailableClients 方法以获取一系列可用插件。

您可以轻松扩展 Composer 类，以便能够创建所需插件的实例，而不是只告诉您哪些插件可用。

您可能会在某些 DI 容器中找到此功能。IIRC，Castle Windsor公开了一个Tester/Doer API，如果MEF也支持这样的功能，我不会感到惊讶。

以下 xUnit.net 参数测试表明上述Composer有效。

public class Tests
{
    [Theory, ClassData(typeof(TestCases))]
    public void AllServicesAreAvailable(
        Type[] availableServices,
        Type[] expected)
    {
        var composer = new Composer(availableServices);
        var actual = composer.GetAvailableClients(
            typeof(Plugin1), typeof(Plugin2), typeof(Plugin3));
        Assert.True(new HashSet<Type>(expected).SetEquals(actual));
    }
}
internal class TestCases : IEnumerable<Object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[] {
            new[] { typeof(IFoo), typeof(IBar), typeof(IBaz) },
            new[] { typeof(Plugin1), typeof(Plugin2), typeof(Plugin3) }
        };
        yield return new object[] {
            new[] { typeof(IBar), typeof(IBaz) },
            new[] { typeof(Plugin2), typeof(Plugin3) }
        };
        yield return new object[] {
            new[] { typeof(IFoo), typeof(IBaz) },
            new[] { typeof(Plugin1) }
        };
        yield return new object[] {
            new[] { typeof(IFoo), typeof(IBar) },
            new[] { typeof(Plugin1), typeof(Plugin3) }
        };
        yield return new object[] {
            new[] { typeof(IFoo) },
            new[] { typeof(Plugin1) }
        };
        yield return new object[] {
            new[] { typeof(IBar) },
            new[] { typeof(Plugin3) }
        };
        yield return new object[] {
            new[] { typeof(IBaz) },
            new Type[0]
        };
        yield return new object[] {
            new Type[0],
            new Type[0]
        };
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

经验教训：

1. 最初我认为我需要每次调用方法注入，这很复杂，因为：

   在
   • 实例化类之前，很难判断是否可以满足依赖项
   • 方法签名不是完全类型安全的，或者不是（非泛型）接口的一部分。
   • 尽管它可能是非标准的，因此不容易被现有系统支持

2. 然后，我通过将所需的依赖项添加为属性来切换到一种属性注入，每个依赖项都绑定到一个接口，以便可以轻松发现所需的依赖项。调用本身是无参数的。

   • 这样可以更轻松地找出可以使用哪个插件。
   • "如果此插件实现了用于设置此依赖项属性的接口，请设置它"语句链可以在调用无参数方法之前填充依赖项。
   • 如果省略一个调用，则不会设置依赖项。

3. 可能正确的方法是使用构造函数注入，因此可以使用标准工具。调用本身也是无参数的，因此它将非常适合接口。

下面是 Mark 解决方案的更完整版本，包括解析组件。它使用Castle.Windsor，xUnit，Shouldly和Resharper的NotNull, CanBeNull属性。

需要进一步的工作来消除对 Castle.Windsor 的直接依赖，方法是注入解析设施工厂（因为它必须接受来自主机的实例，我们不能直接传入解析器）。

public interface IFoo { }
public interface IBar { }
public interface IBaz { }
/// <summary>
/// Needed to invoke the plugin
/// </summary>
public interface IPlugin
{
    void Invoke();
}
public class Plugin1 : IPlugin
{
    public readonly IFoo Foo;
    public Plugin1([NotNull] IFoo foo)
    {
        if (foo == null) throw new ArgumentNullException("foo");
        this.Foo = foo;
    }
    public void Invoke()
    {
        ;
    }
}
public class Plugin2 : IPlugin
{
    public readonly IBar Bar;
    public readonly IBaz Baz;
    public Plugin2([NotNull] IBar bar, [NotNull] IBaz baz)
    {
        if (bar == null) throw new ArgumentNullException("bar");
        if (baz == null) throw new ArgumentNullException("baz");
        this.Bar = bar;
        this.Baz = baz;
    }
    public void Invoke()
    {
        ;
    }
}
public class Plugin3 : IPlugin
{
    public readonly IBar Bar;
    public readonly IBaz Baz;
    public Plugin3([NotNull] IBar bar, [CanBeNull] IBaz baz = null)
    {
        if (bar == null) throw new ArgumentNullException("bar");
        this.Bar = bar; ;
        this.Baz = baz;
    }
    public void Invoke()
    {
        ;
    }
}
public class Bar : IBar
{
}
public class SampleHostTest
{

    [Fact]
    void SampleHostCanResolvePlugin3ButNot1And2()
    {
        var bar = new Bar();
        var plugins = Assembly.GetAssembly(typeof(SampleHost))
                .GetTypes()
                .Where(t => t.IsClass && typeof(IPlugin).IsAssignableFrom(t))
                .ToArray();
        var sut = new SampleHost(bar, plugins);
        sut.IsPluginSupported(typeof(Plugin1)).ShouldBeFalse();
        sut.IsPluginSupported(typeof(Plugin2)).ShouldBeFalse();
        sut.IsPluginSupported(typeof(Plugin3)).ShouldBeTrue();
    }
    [Fact]
    void ResolvePlugin3()
    {
        var bar = new Bar();
        var plugins = Assembly.GetAssembly(typeof(SampleHost))
                .GetTypes()
                .Where(t => t.IsClass && typeof(IPlugin).IsAssignableFrom(t))
                .ToArray();
        var sut = new SampleHost(bar, plugins);
        sut.IsPluginSupported(typeof(Plugin3)).ShouldBeTrue();
        sut.CreateAndInvokePlugin(typeof(Plugin3));
        // no exception => succeeded
    }

}
public class SampleHost
{
    private readonly IBar bar;
    private readonly IWindsorContainer container;
    private Type[] plugins;
    public SampleHost(IBar bar, IEnumerable<Type> plugins)
    {
        this.bar = bar;
        this.plugins = plugins.ToArray();
        this.container = new WindsorContainer();
        container.Register(Component.For<IBar>().Instance(this.bar));
        foreach (var plugin in this.plugins)
        {
            container.Register(Component.For(plugin).ImplementedBy(plugin).LifestyleTransient());
        }
    }
    public bool IsPluginSupported(Type type)
    {
        var result = container.Kernel.HasComponent(type) &&
                     container.Kernel.GetHandler(type).CurrentState == HandlerState.Valid;
        return result;
    }
    public void CreateAndInvokePlugin(Type type)
    {
        Assert.True(IsPluginSupported(type));
        var plugin = container.Resolve(type)as IPlugin;
        Debug.Assert(plugin != null, "plugin != null");
        plugin.Invoke();
    }

}