您好，我正在尝试实现我在 this article 中找到的扩展方法对于简单的注入(inject)器，因为它不支持开箱即用的特定构造函数的注册。

根据这篇文章，我需要用一个假的委托(delegate)来注册服务，但由于我使用的是开放通用的，所以我不能这样做。

到目前为止，这是我完成的代码:

 public sealed class ConstructorSelector : IConstructorSelector
    {
        public static readonly IConstructorSelector MostParameters =
            new ConstructorSelector(type => type.GetConstructors()
                .OrderByDescending(c => c.GetParameters().Length).First());

        public static readonly IConstructorSelector LeastParameters =
            new ConstructorSelector(type => type.GetConstructors()
                .OrderBy(c => c.GetParameters().Length).First());

        private readonly Func _selector;

        public ConstructorSelector(Func selector)
        {
            _selector = selector;
        }

        public ConstructorInfo GetConstructor(Type type)
        {
            return _selector(type);
        }
    }

    public interface IConstructorSelector
    {
        ConstructorInfo GetConstructor(Type type);
    }

    public static class SimpleInjectorExtesions
    {
        public static void RegisterOpenGeneric(this Container container,
            Type serviceType, 
            Type implementationtype, IConstructorSelector selector)
        {   
            //TODO: register the service with a fake delegate   
            container.ExpressionBuilt += (sender, e) =>
            {
                if (e.RegisteredServiceType != serviceType) return;
                var ctor = selector.GetConstructor(implementationtype);

                var parameters =
                    from p in ctor.GetParameters()
                    select container.GetRegistration(p.ParameterType, true)
                                    .BuildExpression();

                e.Expression = Expression.New(ctor, parameters);
            };
        }       
    }

câu trả lời hay nhất

since it doesn't support registration for an specific constructor out of the box

Simple Injector 不支持这个是有充分理由的。你应该更喜欢让你的组件有一个单一的公共(public)构造函数。有multiple constructors is considered to be an anti-pattern .

如果出于某种原因您不能遵循此建议，这里有一些替代方案。

一个简单的解决方案是在 Composition Root 中创建一个新类型它继承自开放泛型类型并仅定义一个构造函数。您可以改为注册该类型:

// new sub type
private sealed class SingleCtorOpenType : OpenType
{
    public SingleCtorOpenType(IDep1 dep1, IDep2 dep2) 
        : base(dep1, dep2) { }
}

// registration
container.RegisterOpenGeneric(
    typeof(IOpenType<>), 
    typeof(SingleCtorOpenType<>));

如果您只处理一种类型，这是最实用的解决方案。如果您有许多具有多个构造函数的类型，则覆盖容器的 constructor resolution behavior会更好。你可以写一个自定义 IConstructorResolutionBehavior开放通用类型的实现:

public class SpecialConstructorResolutionBehavior
    : IConstructorResolutionBehavior
{
    private IConstructorResolutionBehavior original;

    public SpecialConstructorResolutionBehavior(
        IConstructorResolutionBehavior original)
    {
        this.original = original;
    }

    public ConstructorInfo GetConstructor(Type serviceType, 
        Type implementationType)
    {
        if (serviceType.IsGenericType &&
            serviceType.GetGenericTypeDefinition() == typeof(IOpenType<>))
        {
            // do alternative constructor selection here for open types.
            // For instance:
            return (
                from ctor in implementationType.GetConstructors()
                orderby ctor.GetParameters().Length descending
                select ctor)
               .First();
        }

        // fall back to default behavior
        return original.GetConstructor(serviceType, implementationType);
    }
}

您可以按如下方式注册:

container.Options.ConstructorResolutionBehavior =
    new SpecialConstructorResolutionBehavior(
        container.Options.ConstructorResolutionBehavior);

gia hạn

如果你想提供 Expression到强制选择特定构造函数的扩展方法，您可以创建一个扩展方法，除了 Expression<>提取 NewExpression给你这样的:

public static void RegisterOpenGeneric(this Container container, 
    Type openGenericServiceType,
    Type openGenericImplementation, 
    Expression<>

您可以按如下方式调用此扩展方法:

container.RegisterOpenGeneric(typeof(IList<>), typeof(List<>),
    constructorSelector: () => new List());

但是现在麻烦开始了。传入的构造函数来自Danh sách , 但我们应该能够得到任何 List , 所以你必须转换 List.ctor()到您正在解析的类型的构造函数。据我所知，.NET 缺少方便的辅助方法，例如 ConstructorInfo.GetGenericMethodDefinition()Và ConstructorInfo.MakeGenericMethod()重载，因此您需要进行一些查询和调整以找到正确的构造函数。

如果将此模型与 IConstructorResolutionBehavior 集成，这可能是最简单的可扩展性机制，自RegisterOpenGeneric方法调用该接口(interface)。

因此您的解决方案可能如下所示:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using SimpleInjector;
using SimpleInjector.Advanced;
using SimpleInjector.Extensions;

public static class OpenGenericConstructorExtensions
{
    public static void EnableOpenGenericConstructorSelection(
        this ContainerOptions options)
    {
        var selectors = new List<>>();

        options.ConstructorResolutionBehavior = 
            new ConstructorResolutionBehavior(
                options.ConstructorResolutionBehavior, selectors);

        options.Container.SetItem("selectors", selectors);
    }

    public static void RegisterOpenGeneric(this Container container, 
        Type openGenericServiceType,
        Type openGenericImplementation, 
        Expression<>

自定义IConstructorResolutionBehavior需要实现，您将始终必须调用 EnableOpenGenericConstructorSelection这是在上面的例子中定义的。这是代码的使用方式: var container = new Container();

var container = new Container();

container.Options.EnableOpenGenericConstructorSelection();

container.RegisterOpenGeneric(typeof(IList<>), typeof(List<>), 
    constructorSelector: () => new List());

var list = container.GetInstance<>>();
var listOfObject = container.GetInstance<>

关于c# - 使用多个构造函数注册开放泛型的简单注入(inject)器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17904632/