使用 nin注入绑定包装类

本文关键字：包装类 绑定 注入 nin 使用 | 更新日期: 2023-09-27 18:30:17

>我有一个接口，表示第三方API中的表。每个实例都提供使用只进游标搜索单个表的功能：

public interface ITable
{
    string TableName { get; }
    ICursor Search(string whereClause);
}

我编写了一个包装类来处理搜索 ITable 并返回可枚举（它比现实中稍微复杂一些，但足以显示我的问题）：

public interface ITableWrapper
{
    IEnumerable<object> Search(string whereClause);
}
public class TableWrapper : ITableWrapper
{
    private ITable _table;
    public TableWrapper(ITable table)
    {
        _table = table;
    }
    public IEnumerable<Row> Search(string whereClause)
    {
        var cursor = _table.Search(whereClause);
        while(cursor.Next())
        {
            yield return cursor.Row;
        }
    }
}

然后，我有几个存储库类，它们应该注入一个表包装器：

public class Table1Repository
{
    private ITableWrapper _table;
    public Table1Reposiroty(ITableWrapper table)
    {
        _table = table;
    }
    //repository methods to actually do things
}
由于每个表都有自己的包装器，

并且存储库需要正确的表注入，我的想法是在表和包装器上使用命名绑定，以便 ninject 提供正确的实例。因此，上面的类将 NamedAttribute 应用于构造函数参数，绑定如下所示：

public void NinjectConfig(IKernel kernel, ITableProvider provider)
{
    Bind<ITable>().ToMethod(ctx => provider.OpenTable("Table1")).Named("Table1").InSingletonScope();
    Bind<ITableWrapper>().ToMethod(ctx => new TableWrapper(ctx.ContextPreservingGet<ITable>("Table1"))).Named("Table1Wrapper").InSingletonScope();
}

我的问题是：

  1. 有没有更简洁的方式来表达这种绑定？我在想也许有一种方法可以绑定一次 ITableWrapper，并为每个命名的 ITable 返回一个新实例，存储库构造函数参数属性选择它想要 ITableWrapper 的命名 ITable。
  2. 如果 ITable 不应该被任何东西使用，并且所有东西都应该始终使用 ITableWrapper，那么是否可以（甚至推荐）只绑定 ITableWrapper 并结合两个 ToMethod 内容：

public void NinjectConfig(IKernel kernel, ITableProvider provider)
{
    Bind<ITableWrapper>().ToMethod(ctx => new TableWrapper(provider.OpenTable("Table1"))).Named("Table1Wrapper").InSingletonScope();
}

使用 nin注入绑定包装类

没有

Ninject 内置的方式来按属性向 Ninject 提供元数据。它唯一支持的是ConstraintAttribute（以及作为子类的NamedAttribute）。这可用于选择特定绑定，但不能用于为绑定提供参数。

因此，如果您不想添加大量代码，最简单，最简洁的方法是按照您自己的建议：

public static BindTable(IKernel kernel, ITableProvider tableProvider, string tableName)
{
    kernel.Bind<ITableWrapper>()
          .ToMethod(ctx => new tableWrapper(tableProvider.OpenTable(tableName))
          .Named(tableName);
}

（我在这里对表名和 ITableWrapper 名称使用相同的字符串 ID - 这样你就不需要映射它们了）。

另外，我认为如果您不打算使用它，最好不要为ITable创建绑定。

注意：如果要通过工厂创建ITableWrapper（而不是注入 ctor），则可以使用参数和从参数读取表标识的绑定。这意味着单个绑定就足够了。

通用解决方案

现在，如果您可以添加一些自定义代码，您实际上可以实现通用解决方案。如何？添加自定义属性以替换提供表名称的NamedAttribute。此外，您还可以创建一个绑定，用于从此自定义属性读取表名。比方说：

[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = true)]
public class TableIdAttribute : Attribute
{
    public TableIdAttribute(string tableName)
    {
        TableName = tableName;
    }
    public string TableName { get; private set; }
}

让我们实现一个IProvider来封装增加的绑定复杂性（它也适用于ToMethod绑定）：

internal class TableWrapperProvider : Provider<ITableWrapper>
{
    private readonly ITableProvider _tableProvider;
    public TableWrapperProvider(ITableProvider tableProvider)
    {
        _tableProvider = tableProvider;
    }
    protected override ITableWrapper CreateInstance(IContext context)
    {
        var parameterTarget = context.Request.Target as ParameterTarget;
        if (parameterTarget == null)
        {
            throw new ArgumentException(
                string.Format(
                    CultureInfo.InvariantCulture,
                    "context.Request.Target {0} is not a {1}",
                    context.Request.Target.GetType().Name,
                    typeof(ParameterTarget).Name));
        }
        var tableIdAttribute = parameterTarget.Site.GetCustomAttribute<TableIdAttribute>();
        if (tableIdAttribute == null)
        {
            throw new InvalidOperationException(
                string.Format(
                    CultureInfo.InvariantCulture,
                    "ParameterTarget {0}.{1} is missing [{2}]",
                    context.Request.Target,
                    context.Request.Target.Member,
                    typeof(TableIdAttribute).Name));
        }
        return new TableWrapper(_tableProvider.Open(tableIdAttribute.TableName));
    }
}

以下是我们如何使用它（示例类）：

public class FooTableUser
{
    public FooTableUser([TableId(Tables.FooTable)] ITableWrapper tableWrapper)
    {
        TableWrapper = tableWrapper;
    }
    public ITableWrapper TableWrapper { get; private set; }
}
public class BarTableUser
{
    public BarTableUser([TableId(Tables.BarTable)] ITableWrapper tableWrapper)
    {
        TableWrapper = tableWrapper;
    }
    public ITableWrapper TableWrapper { get; private set; }
}

这是绑定和测试：

var kernel = new StandardKernel();
kernel.Bind<ITableProvider>().ToConstant(new TableProvider());
kernel.Bind<ITableWrapper>().ToProvider<TableWrapperProvider>();
kernel.Get<FooTableUser>().TableWrapper.Table.Name.Should().Be(Tables.FooTable);
kernel.Get<BarTableUser>().TableWrapper.Table.Name.Should().Be(Tables.BarTable);
相关文章：