如何使用使用泛型和依赖注入的存储库接口？

Question

我正在尝试使用以下通用存储库接口进行 DI 和构造函数注入：

public interface IRepository<TEntity> : IDisposable where TEntity : class

问题是为了定义接口的实例，我必须提供这样的类类型：

private IRepository<Person> _personRepository;

问题是如果我使用 DI（并且我使用 Unity for IoC 框架），那么我必须在构造函数中定义多个实例以获取我需要使用的所有存储库接口，如下所示：

public MyClass(IRepository<Person> personRepository,
               IRepository<Orders> ordersRepository,
               IRepository<Items> itemsRepository,
               IRepository<Locations> locationsRepository)
{
  _personRepository = personRepository;
  _OrdersRepository = ordersRepository; 
  _itemsRepository = itemsRepository;
  _locationsRepository = locationsRepository;
}

问题：

1. 这样可以吗？
2. 如果不是，我在哪里迷失了这个概念？
3. 即使这是正确的，Unity 将接口注册到具体类型有什么意义？我已经这样做了，因为通用存储库强迫我声明。

请帮我解决这个问题，感谢您的所有帮助！

Answer 1

正如 D Stanley 所指出的，依赖项必须是具体的接口。否则，你要在哪里声明 T？你的依赖类可能是通用的，但在某些时候你仍然必须说“T 是一个人”。

也就是说，Unity 可以很好地处理注册泛型类型。

假设您使用一个通用类Repository<T> 来实现IRepository<T>，该类包装了一个DbSet<T>（或其他）。

随后将进行以下注册和解析（包括注入任何构造函数）：

container.RegisterType(typeof(IRepository<>), typeof(Repository<>));

// no specific registration needed for the specific type resolves
container.Resolve(<IRepository<Person>);
container.Resolve(<IRepository<Order>); 

如果您需要特定类型的覆盖（说 Items 存储库出于某种原因是特殊的，因此它具有完全实现的 ItemRepository 类），只需在通用实现之后注册该特定实现：

container.RegisterType<IRepository<Item>, ItemRepository>();

解析IRespository<Item>现在会得到你的具体实现。

为了记录，我认为这只能在代码中完成，而不是配置文件。有人可以随意纠正这个假设。

Answer 2

这样好吗？

当然。个人偏好是像你一样使用构造函数注入还是属性注入。构造函数注入更简洁，因为您不必为构造函数提供大量参数，但它也更安全。

Unity 将接口注册到具体类型有什么意义

一个原因是您可以对MyClass 进行单元测试，而不必使用访问数据库的实际存储库。您可以“伪造”存储库以返回硬编码值以进行测试。

Answer 3

您可以考虑使用将其他几个服务捆绑在一起的Aggregate Service，但您还应该仔细查看您的MyClass 是否为trying to do too much；拥有大量依赖项可能表明这一点。

Answer 4

这似乎没问题，只是缺少一点；您需要 UnitOfWork 模式来启用事务。 如果没有应用 UnitOfWork 模式，所有存储库都会尝试在不同的上下文中提交数据库操作。

Answer 5

我需要使用配置文件来做到这一点。这实际上很容易，但我花了一段时间才弄清楚。

在这个例子中，我们有一个接口IRepository<T>，它有两个实现：

1. OneRepository
2. TwoRepository

然后我们有一个名为Worker 的类，它依赖于IRepository<One> 和IRepository<Two>。我们要求 unity 为我们创建一个 Worker 的实例，并从配置文件中找出依赖关系。

接口和实现

在本例中，所有这些都在命名空间 ConsoleApplication1 中。

public class Worker
{
    private readonly IRepository<One> one;
    private readonly IRepository<Two> two;

    public Worker(IRepository<One> one, IRepository<Two> two)
    {
        this.one = one;
        this.two = two;
    }

    public string DoOne()
    {
        return this.one.Add(new One());
    }

    public string DoTwo()
    {
        return this.two.Add(new Two());
    }
}

public interface IRepository<T>
{
    string Add(T t);
}

public class OneRepository : IRepository<One>
{
    public string Add(One t)
    {
        return "One";
    }
}

public class TwoRepository : IRepository<Two>
{
    public string Add(Two t)
    {
        return "Two";
    }
}

public class One { }
public class Two { }

统一配置

请注意我们指示unity并告诉它程序集的名称。然后我们注册这 2 个实现。

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
  </configSections>
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <assembly name="ConsoleApplication1" />
    <container>
      <register type="ConsoleApplication1.IRepository[[ConsoleApplication1.One]]" mapTo="ConsoleApplication1.OneRepository" />
      <register type="ConsoleApplication1.IRepository[[ConsoleApplication1.Two]]" mapTo="ConsoleApplication1.TwoRepository" />
    </container>
  </unity>
</configuration>

应用程序

这是Composition Root。

public class Program
{
    static void Main()
    {
        UnityContainer container = new UnityContainer();
        var res = container.LoadConfiguration();
        Worker worker = res.Resolve<Worker>();
        Console.WriteLine(worker.DoOne());
        Console.WriteLine(worker.DoTwo());
        Console.Read();
    }
}

预期的输出是：

One
Two