为 2+ 依赖类注入上下文绑定，为同一构造函数参数注入不同名称

本文关键字：注入 构造函数 参数 依赖 上下文 绑定 | 更新日期: 2023-09-27 18:36:37

在两个类具有相同的底层接口依赖项的情况下，无法弄清楚如何管理上下文绑定，但每个类 ctor 的参数命名不同。 下面的伪代码来演示我的情况：

    interface IThing { }
    public class Thing1 : IThing { public Thing1(string fileCode) { } }
    public class Thing2 : IThing { public Thing2(string fileCode) { } }
    interface IThingFactory { IThing CreateThing(string fileCode); }
    interface IDependentThing { }
    public class A : IDependentThing { public A(string fileCode, IThingFactory thingFactory) { } }
    public class B : IDependentThing { public B(string fileCd, IThingFactory thingFactory) { } } //How to handle binding for this dependent?
    interface IDependentThingFactory { IDependentThing CreateDependentThing(string fileCode); }
    //...
    public override void Load()
    {
        Bind<IThing>().ToMethod(ctx =>
        {
            var fileCode = ctx.Parameters.First(p => p.Name == "fileCode").GetValue(ctx, null) as string;
            IThing thing = null;
            if (fileCode == "FileType1")
            {
                Bind<Thing1>().ToSelf().WithConstructorArgument("fileCode", fileCode);
                thing = Kernel.Get<Thing1>();
            }
            else if (fileCode == "FileType2")
            {
                Bind<Thing2>().ToSelf().WithConstructorArgument("fileCode", fileCode);
                thing = Kernel.Get<Thing2>();
            }
            return thing;
        });
        Bind<IThingFactory>().ToFactory();
        Bind<IDependentThingFactory>().ToFactory();
    }
//Later...
using (TextReader tr = new StreamReader(path))
{
    string firstLine = tr.ReadLine();
    if (firstLine.Substring(838, 1) == ".")
    {
        fileCode = "FileType1";
    }
    else if (firstLine.Substring(883, 1) == ".")
    {
        fileCode = "FileType2";
    }
    //won't work for creating B
    Kernel.Get<IDependentThing>(new ConstructorArgument("fileCode", fileCode));
    //or maybe...
    //seems to eliminate my problem by allowing me to handle variations
    //in parameter names  from within A and B's ctors, but looks like it
    //requires injecting factories along the chain (see A & B ctor arguments).
    dependentThingFactory.CreateDependentThing(fileCode) 
};

fileCode是根据对本地文件的一些分析计算得出的。 确定文件类型后，我希望 Ninject 交回适当的对象来处理该文件

我将如何处理B的绑定，因为我定义的现有绑定需要具有不同名称的构造函数参数？一般来说，有没有更好的方法来做到这一点？

我想我可以用p.Name == "fileCode" || p.Name == "fileCd"，但我无法摆脱我做错了什么的感觉（感觉很乱）。 此外，我对按名称拉取参数并不感到兴奋，并且我已经考虑过可能创建一个自定义类型，该类型将为 Ninject 提供更具体的东西来匹配字符串参数。 从我的立场来看，我要么只是管理多个参数名称的情况，要么切换到自定义类型作为我的参数而不是字符串。

为 2+ 依赖类注入上下文绑定，为同一构造函数参数注入不同名称

使参数注入更加安全重构并使其可用于整个解析上下文

您可以使用"类型

匹配"或"类型化"参数代替"命名参数"。IInstanceProvider工厂可以换成另一个工厂：

kernel.Bind<IThingFactory>()
      .ToFactory(() => new TypeMatchingArgumentInheritanceInstanceProvider());

注意：

  • 此IInstanceProvider还将使参数进一步"下游"可用（它"继承"参数）
  • string非常冗长，因此您可能希望选择将其包装为另一种类型，例如 class ConnectionInfo 。

上下文绑定与参数注入相结合

因此，假设我们创建自己的FileType类型，使其比仅使用string更详细：

public class FileCode
{
    public FileCode(string value)
    {
        Value = value;
    }
    public string Value { get; private set; }
}

（也许你想用enum代替它？

由于您的要求更加复杂，我们将不得不稍微改变一下。我们将创建自己的IConstructorArgument，以便能够轻松地将其匹配为When上下文绑定，并根据类型匹配注入其值（如上所述）：

internal class FileCodeParameter : IConstructorArgument
{
    private readonly FileCode fileCode;
    public FileCodeParameter(FileCode fileCode)
    {
        this.fileCode = fileCode;
    }
    public string Name { get { return "File Code Parameter"; } }
    public bool ShouldInherit { get { return true; } }
    public FileCode FileCode  { get { return this.fileCode; } }
    public bool Equals(IParameter other)
    {
        var otherFileCodeParameter = other as FileCodeParameter;
        if (otherFileCodeParameter == null)
        {
            return false;
        }
        return otherFileCodeParameter.fileCode == this.fileCode;
    }
    public object GetValue(IContext context, ITarget target)
    {
        return this.fileCode;
    }
    public bool AppliesToTarget(IContext context, ITarget target)
    {
        return target.Type == typeof(FileCode);
    }
}

现在让我创建一些示例代码，以便我们稍后验证它是否有效：

public interface IThing
{
    FileCode FileCode { get; }
}
public abstract class Thing : IThing
{
    protected Thing(FileCode fileCode)
    {
        FileCode = fileCode;
    }
    public FileCode FileCode { get; private set; }
}
public class ThingFoo : Thing
{
    public ThingFoo(FileCode fileCode) : base(fileCode) { }
}
public class ThingBar : Thing
{
    public ThingBar(FileCode fileCode) : base(fileCode) { }
}
public interface IOtherThing
{
    FileCode FileCode { get; }
}
public abstract class OtherThing : IOtherThing
{
    protected OtherThing(FileCode fileCode)
    {
        FileCode = fileCode;
    }
    public FileCode FileCode { get; private set; }
}
public class OtherThingFoo : OtherThing
{
    public OtherThingFoo(FileCode fileCode) : base(fileCode) { }
}
public class OtherThingBar : OtherThing
{
    public OtherThingBar(FileCode fileCode) : base(fileCode) { }
}
public class OtherThingWrapper
{
    public OtherThingWrapper(IOtherThing otherThing)
    {
        OtherThing = otherThing;
    }
    public IOtherThing OtherThing { get; private set; }
}
public class FileProcessor
{
    public FileProcessor(IThing thing, OtherThingWrapper otherThingWrapper)
    {
        Thing = thing;
        OtherThingWrapper = otherThingWrapper;
    }
    public IThing Thing { get; private set; }
    public OtherThingWrapper OtherThingWrapper { get; private set; }
}

缺少什么？工厂。我们可以将ToFactory绑定与自定义IInstanceProvider一起使用，但除非我们要创建许多具有FileCodeParameter的工厂，否则我认为这没有意义，所以让我们保持简单：

public interface IFileProcessorFactory
{
    FileProcessor Create(FileCode fileCode);
}
internal class FileProcessorFactory : IFileProcessorFactory
{
    private readonly IResolutionRoot resolutionRoot;
    public FileProcessorFactory(IResolutionRoot resolutionRoot)
    {
        this.resolutionRoot = resolutionRoot;
    }
    public FileProcessor Create(FileCode fileCode)
    {
        return this.resolutionRoot.Get<FileProcessor>(new FileCodeParameter(fileCode));
    }
}

现在让我们把所有的东西放在一起：

public class Test
{
    [Fact]
    public void FactMethodName()
    {
        var fooFileCode = new FileCode("foo");
        var barFileCode = new FileCode("bar");
        var kernel = new StandardKernel();
        kernel
            .Bind<IFileProcessorFactory>()
            .To<FileProcessorFactory>();
        kernel
            .Bind<IThing>()
            .To<ThingFoo>()
            .WhenFileCode(fooFileCode);
        kernel
            .Bind<IThing>()
            .To<ThingBar>()
            .WhenFileCode(barFileCode);
        kernel
            .Bind<IOtherThing>()
            .To<OtherThingFoo>()
            .WhenFileCode(fooFileCode);
        kernel
            .Bind<IOtherThing>()
            .To<OtherThingBar>()
            .WhenFileCode(barFileCode);

        var fileProcessor = kernel.Get<IFileProcessorFactory>().Create(barFileCode);
        fileProcessor.Thing.Should().BeOfType<ThingBar>();
        fileProcessor.Thing.FileCode.Should().Be(barFileCode);
        fileProcessor.OtherThingWrapper.OtherThing.Should().BeOfType<OtherThingBar>();
        fileProcessor.OtherThingWrapper.OtherThing.FileCode.Should().Be(barFileCode);
    }
}
public static class BindingExtensionsForFileCodes
{
    public static IBindingInNamedWithOrOnSyntax<T> WhenFileCode<T>(
        this IBindingWhenSyntax<T> syntax,
        FileCode fileCode)
    {
        return syntax.When(req => req
            .Parameters
            .OfType<FileCodeParameter>()
            .Single()
            .FileCode.Value == fileCode.Value);
    }
}

就是这样！ - FileCode正在注入并用于选择实现 - 由于参数是"继承的"，因此它也在对象树的更深处工作。

下面，仅供参考，所有代码以便于复制和粘贴：

using FluentAssertions;
using Ninject;
using Ninject.Activation;
using Ninject.Parameters;
using Ninject.Planning.Targets;
using Ninject.Syntax;
using System.Linq;
using Xunit;
namespace NinjectTest.ParameterContextual
{
    public class FileCode
    {
        public FileCode(string value)
        {
            Value = value;
        }
        public string Value { get; private set; }
    }
    public interface IThing
    {
        FileCode FileCode { get; }
    }
    public abstract class Thing : IThing
    {
        protected Thing(FileCode fileCode)
        {
            FileCode = fileCode;
        }
        public FileCode FileCode { get; private set; }
    }
    public class ThingFoo : Thing
    {
        public ThingFoo(FileCode fileCode) : base(fileCode) { }
    }
    public class ThingBar : Thing
    {
        public ThingBar(FileCode fileCode) : base(fileCode) { }
    }
    public interface IOtherThing
    {
        FileCode FileCode { get; }
    }
    public abstract class OtherThing : IOtherThing
    {
        protected OtherThing(FileCode fileCode)
        {
            FileCode = fileCode;
        }
        public FileCode FileCode { get; private set; }
    }
    public class OtherThingFoo : OtherThing
    {
        public OtherThingFoo(FileCode fileCode) : base(fileCode) { }
    }
    public class OtherThingBar : OtherThing
    {
        public OtherThingBar(FileCode fileCode) : base(fileCode) { }
    }
    public class OtherThingWrapper
    {
        public OtherThingWrapper(IOtherThing otherThing)
        {
            OtherThing = otherThing;
        }
        public IOtherThing OtherThing { get; private set; }
    }
    public class FileProcessor
    {
        public FileProcessor(IThing thing, OtherThingWrapper otherThingWrapper)
        {
            Thing = thing;
            OtherThingWrapper = otherThingWrapper;
        }
        public IThing Thing { get; private set; }
        public OtherThingWrapper OtherThingWrapper { get; private set; }
    }
    public interface IFileProcessorFactory
    {
        FileProcessor Create(FileCode fileCode);
    }
    internal class FileProcessorFactory : IFileProcessorFactory
    {
        private readonly IResolutionRoot resolutionRoot;
        public FileProcessorFactory(IResolutionRoot resolutionRoot)
        {
            this.resolutionRoot = resolutionRoot;
        }
        public FileProcessor Create(FileCode fileCode)
        {
            return this.resolutionRoot.Get<FileProcessor>(new FileCodeParameter(fileCode));
        }
    }
    public class Test
    {
        [Fact]
        public void FactMethodName()
        {
            var fooFileCode = new FileCode("foo");
            var barFileCode = new FileCode("bar");
            var kernel = new StandardKernel();
            kernel
                .Bind<IFileProcessorFactory>()
                .To<FileProcessorFactory>();
            kernel
                .Bind<IThing>()
                .To<ThingFoo>()
                .WhenFileCode(fooFileCode);
            kernel
                .Bind<IThing>()
                .To<ThingBar>()
                .WhenFileCode(barFileCode);
            kernel
                .Bind<IOtherThing>()
                .To<OtherThingFoo>()
                .WhenFileCode(fooFileCode);
            kernel
                .Bind<IOtherThing>()
                .To<OtherThingBar>()
                .WhenFileCode(barFileCode);

            var fileProcessor = kernel.Get<IFileProcessorFactory>().Create(barFileCode);
            fileProcessor.Thing.Should().BeOfType<ThingBar>();
            fileProcessor.Thing.FileCode.Should().Be(barFileCode);
            fileProcessor.OtherThingWrapper.OtherThing.Should().BeOfType<OtherThingBar>();
            fileProcessor.OtherThingWrapper.OtherThing.FileCode.Should().Be(barFileCode);
        }
    }
    internal class FileCodeParameter : IConstructorArgument
    {
        private readonly FileCode fileCode;
        public FileCodeParameter(FileCode fileCode)
        {
            this.fileCode = fileCode;
        }
        public string Name { get { return "File Code Parameter"; } }
        public bool ShouldInherit { get { return true; } }
        public FileCode FileCode  { get { return this.fileCode; } }
        public bool Equals(IParameter other)
        {
            var otherFileCodeParameter = other as FileCodeParameter;
            if (otherFileCodeParameter == null)
            {
                return false;
            }
            return otherFileCodeParameter.fileCode == this.fileCode;
        }
        public object GetValue(IContext context, ITarget target)
        {
            return this.fileCode;
        }
        public bool AppliesToTarget(IContext context, ITarget target)
        {
            return target.Type == typeof(FileCode);
        }
    }
    public static class BindingExtensionsForFileCodes
    {
        public static IBindingInNamedWithOrOnSyntax<T> WhenFileCode<T>(
            this IBindingWhenSyntax<T> syntax,
            FileCode fileCode)
        {
            return syntax.When(req => req
                .Parameters
                .OfType<FileCodeParameter>()
                .Single()
                .FileCode.Value == fileCode.Value);
        }
    }
}
相关文章：