如何使用约定将接口有条件地绑定到类型，这取决于它被注入了什么

本文关键字：取决于 什么 注入 类型 约定 何使用 接口 有条件 绑定 | 更新日期: 2023-09-27 18:06:07

我有很多类型的构造函数接受一个ICommand参数，像这样:

public AboutCommandMenuItem(ICommand command)
    : base(command)
{
}

public OptionsCommandMenuItem(ICommand command) 
    : base(command)
{
}

我正在使用Ninject，我有ICommand接口配置如下:

_kernel.Bind<ICommand>().To<AboutCommand>().WhenInjectedExactlyInto<AboutCommandMenuItem>();
_kernel.Bind<ICommand>().To<OptionsCommand>().WhenInjectedExactlyInto<OptionsCommandMenuItem>();

是否有一种方法来设置一个约定，以便我可以绑定ICommand接口到XxxxCommand时，它注入到XxxxCommandMenuItem，并避免手动配置每一个可能的类型的接口可以注入?

我尝试了BindToSelection，但选择器表达式没有捕获我注入的类型，BindToRegex似乎只不过是一个字符串类型的选择器。

这是我能得到的最接近的:

_kernel.Bind(t => t.FromThisAssembly()
    .SelectAllClasses()
    .InNamespaceOf<ICommand>()
    .EndingWith("Command")
    .Where(type => type.GetInterfaces().Contains(typeof(ICommand)))
    .BindAllInterfaces()
    .Configure(binding => binding
        .When(request => request.Service == typeof(ICommand) 
                      && request.Target.Member.DeclaringType.Name.StartsWith(?)));

其中?为被选择绑定的类名。

我被显式绑定困住了吗?

如何使用约定将接口有条件地绑定到类型，这取决于它被注入了什么

根据其他约束条件，调整设计以不共享ICommand接口可能会更好。为什么?将OptionsCommand注入AboutCommandMenuItem是没有意义的。但是AboutCommandMenuItem的向量使它看起来好像是可以的。

然而，我假设你仍然想继续这个。这里有几个可能的解决方案(不影响你的设计选择):

  • 命名绑定。您可以使用IBindingGenerator的约定来创建绑定
  • 您已经找到的When条件的方法。同样，将它与IBindingGenerator结合使用
    • 备选方案a)条件检查名称或类型。匹配类型作为When表达式执行的一部分计算
    • 备选方案b)绑定生成器计算匹配类型，When表达式只进行比较。

最后一个选项/备选方案的范例实现:

Codez

(有趣的部分优先)

测试(演示ItWorxxTm)

using FluentAssertions;
using Ninject;
using Ninject.Extensions.Conventions;
using Xunit;
public class MenuItemCommandConventionTest
{
    [Fact]
    public void Test()
    {
        var kernel = new StandardKernel();
        kernel.Bind(x => x
            .FromThisAssembly()
            .IncludingNonePublicTypes()
            .SelectAllClasses()
            .InheritedFrom<ICommand>()
            .BindWith<CommandBindingGenerator>());
        kernel.Get<AboutMenuItem>()
              .Command.Should().BeOfType<AboutCommand>();
        kernel.Get<OptionsMenuItem>()
              .Command.Should().BeOfType<OptionsCommand>();
    }
}

绑定生成器:

using Ninject.Extensions.Conventions.BindingGenerators;
using Ninject.Syntax;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
public class CommandBindingGenerator : IBindingGenerator
{
    private const string CommandSuffix = "Command";
    private const string MenuItemTypeNamePattern = "{0}MenuItem";
    public IEnumerable<IBindingWhenInNamedWithOrOnSyntax<object>> CreateBindings(
        Type type, IBindingRoot bindingRoot)
    {
        string commandName = GetCommandName(type);
        Type menuItem = FindMatchingMenuItem(type.Assembly, commandName);
        var binding = bindingRoot.Bind(typeof(ICommand)).To(type);
        // this is a slight hack due to the return type limitation
        // but it works as longs as you dont do Configure(x => .When..)
        binding.WhenInjectedInto(menuItem); 
        yield return binding;
    }
    private static Type FindMatchingMenuItem(
        Assembly assembly, string commandName)
    {
        string expectedMenuItemTypeName = string.Format(
            CultureInfo.InvariantCulture, 
            MenuItemTypeNamePattern,
            commandName);
        Type menuItemType = assembly.GetTypes()
            .SingleOrDefault(x => x.Name == expectedMenuItemTypeName);
        if (menuItemType == null)
        {
            string message = string.Format(
                CultureInfo.InvariantCulture,
                "There's no type named '{0}' in assembly {1}",
                expectedMenuItemTypeName,
                assembly.FullName);
            throw new InvalidOperationException(message);
        }
        return menuItemType;
    }
    private static string GetCommandName(Type type)
    {
        if (!type.Name.EndsWith(CommandSuffix))
        {
            string message = string.Format(
                CultureInfo.InvariantCulture,
                "the command '{0}' does not end with '{1}'",
                type.FullName,
                CommandSuffix);
            throw new ArgumentException(message);
        }
        return type.Name.Substring(
            0,
            type.Name.Length - CommandSuffix.Length);
    }
}

命令和菜单项:

public interface ICommand
{ 
}
class AboutCommand : ICommand
{
}
internal class OptionsCommand : ICommand
{
}
public abstract class MenuItem
{
    private readonly ICommand command;
    protected MenuItem(ICommand command)
    {
        this.command = command;
    }
    public ICommand Command
    {
        get { return this.command; }
    }
}
public class OptionsMenuItem : MenuItem
{
    public OptionsMenuItem(ICommand command)
        : base(command) { }
}
public class AboutMenuItem : MenuItem
{
    public AboutMenuItem(ICommand command)
        : base(command) { }
}
相关文章：