C# 无法从集合推断泛型类型

为什么不可能做到这一点：

public static void Init<TEntity>(params TEntity[] repositories) where TEntity : Entity
{
    foreach (TEntity item in repositories)
    {
       Repository<item> rep = new Repository<item>();
    }
}

公共静态void Init（params tenty[]存储库），其中tenty:Entity
{
foreach（存储库中的TEntity项）
{
Repository=newrepository（）；
}
}

无法编译上述代码：无法解析符号项

但这是可行的：

public static void Init<TEntity>(TEntity entity) where TEntity : Entity
{
    Repository<TEntity> rep = new Repository<TEntity>();
}

公共静态void Init（tenty实体），其中tenty:entity
{
Repository=newrepository（）；
}

编辑

我正在编辑这篇文章，以便更全面地了解这个问题。我们遇到了由多个存储库生成的实体框架数据库上下文的一些问题。目前，我们访问的存储库如下：

Repository<Product> rep = new Repository<Product>()
Repository<Account> rep = new Repository<Account>()

GetRepository<Product>().GetById(1);
GetRepository<Account>().GetById(123434);

Repository=newrepository（）
Repository=newrepository（）

由于产品和帐户之间存在关系，EF会抱怨对象被附加到不同的上下文。因此，我们正试图通过将存储库访问整合到工作单元模式中来解决此问题：

下面是我试图实现的一个例子：

public class UnitOfWork
{
    protected List<Entity> Repositories = new List<Entity>();
    private readonly DbContext _context;
    protected UnitOfWork()
    {
       _context = new SqlDbContext();
    }

    public static UnitOfWork Init<TEntity>(params TEntity[] repositories) where TEntity : Entity
    {
            UnitOfWork uow = new UnitOfWork();
        foreach (TEntity item in repositories)
        {
            Repository<item> rep = new Repository<item>();
            uow.Repositories.Add(rep);
        }
            return uow;
    }

    public IRepository<T> GetRepository<T>() where T : Entity
    {
        return Repositories.OfType<T>().Single();
    }   
}

公共类UnitOfWork
{
受保护的列表存储库=新列表（）；
私有只读DbContext\u context；
受保护的工作单元（）
{
_context=newsqldbcontext（）；
}
公共静态UnitOfWork Init（params tenty[]存储库），其中tenty:Entity
{
UnitOfWork uow=新UnitOfWork（）；
foreach（存储库中的TEntity项）
{
Repository=newrepository（）；
uow.Repositories.Add（rep）；
}
返回uow；
}
公共IRepository GetRepository（），其中T:Entity
{
返回Repositories.OfType（）.Single（）；
}   
}

因此，我们可以访问我们的存储库，如：

Repository<Product> rep = new Repository<Product>()
Repository<Account> rep = new Repository<Account>()

GetRepository<Product>().GetById(1);
GetRepository<Account>().GetById(123434);

GetRepository（）.GetById（1）；
GetRepository（）.GetById（123434）；

这是不正确的语法。Item是TEntity类型的实例。不能将实例变量与泛型定义一起使用。

这是不正确的语法。Item是TEntity类型的实例。不能将实例变量用于泛型定义。

项

是类型的实例，但需要类型参数来创建泛型

存储库

类的实例。

项

是类型的实例，但是您需要一个类型参数来创建泛型

存储库
类的实例。
不确定是什么让您尝试第一种情况
（
Repository=newrepository（）；
）。这里，“item”是一个实例，而不是一个类型。如果你需要一个泛型项目，你的第二个案例做得最好

请详细说明你的“问题”

编辑：
如果这个问题是出于好奇，那么您可以看看“MakeGenericType”方法，下面的代码解释了它的用法

       Type generic = typeof(Repository<>);

       Type[] typeArgs = { item.GetType() };

       Type constructed = generic.MakeGenericType(typeArgs);
// This will create Repository<item> type.

Type generic=typeof（存储库）；
类型[]typeArgs={item.GetType（）}；
构造的类型=generic.MakeGenericType（typeArgs）；
//这将创建存储库类型。
不确定是什么促使你尝试第一个案例
（
Repository=newrepository（）；
）。这里，“item”是一个实例，而不是一个类型。如果你需要一个泛型项目，你的第二个案例做得最好

请详细说明你的“问题”

编辑：
如果这个问题是出于好奇，那么您可以看看“MakeGenericType”方法，下面的代码解释了它的用法

       Type generic = typeof(Repository<>);

       Type[] typeArgs = { item.GetType() };

       Type constructed = generic.MakeGenericType(typeArgs);
// This will create Repository<item> type.

Type generic=typeof（存储库）；
类型[]typeArgs={item.GetType（）}；
构造的类型=generic.MakeGenericType（typeArgs）；
//这将创建存储库类型。
公共静态UnitOfWork Init（）
{
UnitOfWork uow=新UnitOfWork（）；
添加（新存储库（））；
返回uow；
}
公共静态UnitOfWork Init（）
{
UnitOfWork uow=Init（）；
添加（新存储库（））；
返回uow；
}
公共静态UnitOfWork Init（）
{
UnitOfWork uow=Init（）；
添加（新存储库（））；
返回uow；
}
// ...
公共静态UnitOfWork Init（）
{
UnitOfWork uow=新UnitOfWork（）；
添加（新存储库（））；
返回uow；
}
公共静态UnitOfWork Init（）
{
UnitOfWork uow=Init（）；
添加（新存储库（））；
返回uow；
}
公共静态UnitOfWork Init（）
{
UnitOfWork uow=Init（）；
添加（新存储库（））；
返回uow；
}
// ...
我不知道您为什么需要这样做。如果您知道item是TEntity类型，并且您正试图从item的类型创建一个泛型存储库，为什么不直接创建存储库呢？您的第一个代码显然是错误的，泛型是基于T的编译时特性，其中T是一个实际的类型参数，如
string
或
Foo
。你想把T变成一个变量，这是行不通的。但是您真正需要做的是什么呢？我们在跨多个存储库管理实体框架上下文时遇到了问题，因此尝试将所有存储库放入工作单元模式，以便我们可以使用DbContext的单个实例。既然您已经传入了类型，为什么不能在类和类之外创建存储库通过名单？我不知道你为什么要这么做。如果您知道item是TEntity类型，并且您正试图从item的类型创建一个泛型存储库，为什么不直接创建存储库呢？您的第一个代码显然是错误的，泛型是基于T的编译时特性，其中T是一个实际的类型参数，如
string
或
Foo
。你想把T变成一个变量，这是行不通的。但您真正需要做的是什么？我们在跨多个存储库管理实体框架上下文时遇到了问题，因此尝试将所有存储库放入工作单元模式，以便我们可以使用DbContext的单个实例。既然您已经传入了类型，为什么您不能