Question

在开发我的一个项目期间，我遇到了有关泛型类型的问题。

该项目要求我编写一个可以作为列表对象源的类。假设我有以下课程：

public class TablesProvider
{
    private readonly List[] _tables;

    public TablesProvider()
    {
        // initialize the tables var here....
    }

    public List<TItem> GetTable<TItem>()
    {
        return (List<TItem>)_tables.Single(x => x is List<TItem>);
    }
}

这个类显然不起作用，因为List类型是泛型类型，因此应该指定泛型参数。

所以我创建了一个名为MyList的抽象类型，它可以通过更具体的类型MyList<TItem>派生，以逃避此要求，并稍微编辑TablesProvider。

public class TablesProvider
{
    private readonly MyList[] _tables;

    public TablesProvider()
    {
        // initialize the tables var here....
    }

    public MyList<TItem> GetTable<TItem>()
    {
        return (MyList<TItem>)_tables.Single(x => x is MyList<TItem>);
    }
}

public abstract class MyList
{
    // ...
}

public class MyList<TItem> : MyList, IList<TItem>
{
    private readonly List<TItem> _elements = new List<TItem>();

    public TItem this[int index]
    {
        get { return _elements[index]; }
        set { _elements[index] = value; }
    }

    // ... 
}

这很有效。只剩下一个问题了。假设我有45个不同的集合，每个集合都使用不同的泛型参数定义。初始化所有这些集合的最佳方法是什么？我不能在这里使用for循环，因为泛型参数是在编译时而不是在运行时指定的，因此这样的结构是不可能的：

 for (int i = 0; i < 45; i++)
      _tables[i] = new MyList<GenericParameters[i]>();

我的最终目标是拥有这样的奢侈品......

 var table = _tablesProvider.GetTable<SomeClass>();
 var element = table[3];
 var propertyValue = element.SomeProperty;

...无需转换变量element以访问其特定类型的成员。

值得一提的是，不同列表对象的数量固定为45.这不会改变。从理论上讲，我可以逐行初始化数组，或者改为使用45个属性或变量。然而，这两个选项对我来说都是一个相当便宜的解决方案，但如果没有别的办法，我会接受其中一个。

你们有没有想法？我这样做完全错了吗？我应该考虑其他结构吗？

提前致谢。

Answer 1

此实施工作

public class TablesProvider
{
    private readonly List<object> _tables;

    public TablesProvider()
    {
        _tables = new List<object>();
    }

    public IList<TItem> GetTable<TItem>()
    {
        var lst = (List<TItem>)_tables.SingleOrDefault(x => x is List<TItem>);
        if (lst == null)
        {
            lst = new List<TItem>();
            _tables.Add(lst);
        }
        return lst;
    }
}

必要时创建TItem列表;下次它返回TItem的相同列表。这是懒惰的初始化

所以你可以调用

var table = _tablesProvider.GetTable<SomeClass>();

没有这样的代码：

for (int i = 0; i < 45; i++)
  _tables[i] = new MyList<GenericParameters[i]>();

它不是ThreadSafe

Answer 2

是的，如果您使用反射，可以执行您所描述的内容。

假设您的假设GenericParameters数组是Type的数组（因为您不能拥有标识符类型的数组），您可以定义此辅助功能：

private MyList MakeList(Type t)
{
    return (MyList)Activator.CreateInstance(typeof(MyList<>).MakeGenericType(t));
}

这将允许你这样做：

public TablesProvider()
{
    var GenericParameters = new[] { typeof(string), typeof(int), typeof(DateTime) };

    _tables = new MyList[GenericParameters.Length];

    for (int i = 0; i < GenericParameters.Length; i++)
    {
        _tables[i] = MakeList(GenericParameters[i]);
    }
}

如果您愿意，甚至可以使用LINQ：

public TablesProvider()
{
    var GenericParameters = new[] { typeof(string), typeof(int), typeof(DateTime) };

    _tables = GenericParameters.Select(MakeList).ToArray();
}

<小时/> 上一个答案：

嗯，现实情况是，您将拥有45种不同类型某处的列表，这几乎意味着您将拥有45条不同类似代码的行。所以可以说，目标是使这些线条尽可能简洁。

这样做的一种方法是添加辅助函数：

private void AddTable<T>()
{
    _tables.Add(new MyTable<T>());
}

（假设将_tables更改为List<MyTable>）

然后你可以这样做：

AddTable<Type1>();
AddTable<Type2>();
AddTable<Type3>();
AddTable<Type4>();

使用不同的泛型参数初始化泛型集合数组

2 个答案: