C# 实例化泛型列表

我想实例化一个对象的通用列表，如：

public static class TablesClass
{
    private static IList<Tables<T>> TablesInstance { get; set; }

    static TablesClass() => Tables = new List<Tables<T>>();
    public static void AddTable(Table<t> table) => Tables.Add(table);
}

公共静态类tableClass
{
私有静态IList表实例{get；set；}
静态表类（）=>表=新列表（）；
公共静态void AddTable（Table Table）=>Tables.Add（Table）；
}

我无法更改表，这是一个nuget包类

我怎样才能做到这一点？我所尝试的一切都不起作用（将类型T设置为class，使用对象而不是T和强制转换-这不是理想的解决方案）

---

谁能帮帮我吗？

tableClass

不是泛型类，您没有告诉编译器应该在什么地方使用什么类型的

T

如果您希望能够将不同类型的对象添加到相同的

IList

列表中，

T

必须是所有这些对象的通用基类型

例如，如果希望能够将苹果、梨和香蕉添加到列表中，则类型参数

T

可以指定为

Fruit

，前提是

Fruit

是所有这些类型的基类

---

显然，如果您希望能够访问列表中特定于

Fruit

类的具体实现的项的任何成员，则需要从

Fruit

强制转换，但这是不可避免的。你不会把一堆不同种类的水果扔进一个篮子里，然后期望总是能捡到一种特定的水果，是吗？

你的nuget课程必须是这种风格：

public abstract class Tables
{
}

//the Generic class must has a base, by which you can list them
public class Tables<T> : Tables // where T: something base class of your object
{
    //...
}

公共抽象类表
{
}
//泛型类必须有一个基，通过它可以列出它们
公共类表：表//其中T:something是对象的基类
{
//...
}

那么你的班级必须是：

public static class TablesClass
{
    //Search source code of your Nuget package, find its base class of Generic class, the list must be defined as its base
    private static IList<Tables> Tables { get; set; }

    static TablesClass()
    {
        Tables = new List<Tables>();
    }

    public static void AddTable(Tables table)
    {
        Tables.Add(table);
    }
}

公共静态类tableClass
{
//搜索您的Nuget包的源代码，找到其泛型类的基类，列表必须定义为其基类
私有静态IList表{get；set；}
静态表类（）
{
Tables=新列表（）；
}
公共静态void AddTable（表）
{
表。添加（表）；
}
}

然后你可以这样使用它：

public class Test
{
    public static void Mains()
    {
        TablesClass.AddTable(new Tables<A>());
        TablesClass.AddTable(new Tables<B>());
        TablesClass.AddTable(new Tables<C>());
    }
}

public class Repository
{
    private Dictionary<Type, Dictionary<string, object>> _store
        = new Dictionary<Type, Dictionary<string, object>>();

    public void Store<T>(string key, T value)
    {
        if (!_store.ContainsKey(typeof(T)))
        {
            _store.Add(typeof(T), new Dictionary<string, object>());
        }
        _store[typeof(T)][key] = value;
    }

    public T Fetch<T>(string key)
    {
        return (T)_store[typeof(T)][key];
    }

    public bool TryFetch<T>(string key, out T value)
    {
        var success = _store.ContainsKey(typeof(T)) && _store[typeof(T)].ContainsKey(key);
        value = success ? this.Fetch<T>(key) : default(T);
        return success;
    }

    public bool TryInject<T>(string key, Action<T> inject)
    {
        var success = this.TryFetch<T>(key, out T value);
        if (success)
        {
            inject(value);
        }
        return success;
    }       
}

var repository = new Repository();

repository.Store("a", new TableA());
repository.Store("b", new TableB());
repository.Store("c", new TableC());
repository.Store("d", new TableD());

/* Somewhere else in your code */
TableA a = repository.Fetch<TableA>("a");
TableB b = repository.Fetch<TableB>("b");
TableC c = repository.Fetch<TableC>("c");
TableD d = repository.Fetch<TableD>("d");

公共类测试
{
公共静态电源（）
{
tableClass.AddTable（新表（））；
tableClass.AddTable（新表（））；
tableClass.AddTable（新表（））；
}
}

如果你想做这类事情，你需要使用

对象来保存引用，但是要创建一个方法，允许你使用强类型来存储和获取每个表

尝试这样的课程：

public class Test
{
    public static void Mains()
    {
        TablesClass.AddTable(new Tables<A>());
        TablesClass.AddTable(new Tables<B>());
        TablesClass.AddTable(new Tables<C>());
    }
}

public class Repository
{
    private Dictionary<Type, Dictionary<string, object>> _store
        = new Dictionary<Type, Dictionary<string, object>>();

    public void Store<T>(string key, T value)
    {
        if (!_store.ContainsKey(typeof(T)))
        {
            _store.Add(typeof(T), new Dictionary<string, object>());
        }
        _store[typeof(T)][key] = value;
    }

    public T Fetch<T>(string key)
    {
        return (T)_store[typeof(T)][key];
    }

    public bool TryFetch<T>(string key, out T value)
    {
        var success = _store.ContainsKey(typeof(T)) && _store[typeof(T)].ContainsKey(key);
        value = success ? this.Fetch<T>(key) : default(T);
        return success;
    }

    public bool TryInject<T>(string key, Action<T> inject)
    {
        var success = this.TryFetch<T>(key, out T value);
        if (success)
        {
            inject(value);
        }
        return success;
    }       
}

var repository = new Repository();

repository.Store("a", new TableA());
repository.Store("b", new TableB());
repository.Store("c", new TableC());
repository.Store("d", new TableD());

/* Somewhere else in your code */
TableA a = repository.Fetch<TableA>("a");
TableB b = repository.Fetch<TableB>("b");
TableC c = repository.Fetch<TableC>("c");
TableD d = repository.Fetch<TableD>("d");

公共类存储库
{
私人字典商店
=新字典（）；
公共无效存储（字符串键，T值）
{
如果（！_store.ContainsKey（类型（T）））
{
_Add（typeof（T），newdictionary（））；
}
_存储[typeof（T）][key]=值；
}
公共T获取（字符串键）
{
返回（T）_存储[类型（T）][键]；
}
公共bool TryFetch（字符串键，out T值）
{
var success=_store.ContainsKey（typeof（T））&&_store[typeof（T）].ContainsKey（key）；
value=success？this.Fetch（key）：默认值（T）；
回归成功；
}
公共bool TryInject（字符串键，动作注入）
{
var success=此.TryFetch（键，输出T值）；
如果（成功）
{
注入（值）；
}
回归成功；
}       
}

然后，您可以在存储库（集合）中强键入对象，并按如下方式强键入将其取出：

public class Test
{
    public static void Mains()
    {
        TablesClass.AddTable(new Tables<A>());
        TablesClass.AddTable(new Tables<B>());
        TablesClass.AddTable(new Tables<C>());
    }
}

public class Repository
{
    private Dictionary<Type, Dictionary<string, object>> _store
        = new Dictionary<Type, Dictionary<string, object>>();

    public void Store<T>(string key, T value)
    {
        if (!_store.ContainsKey(typeof(T)))
        {
            _store.Add(typeof(T), new Dictionary<string, object>());
        }
        _store[typeof(T)][key] = value;
    }

    public T Fetch<T>(string key)
    {
        return (T)_store[typeof(T)][key];
    }

    public bool TryFetch<T>(string key, out T value)
    {
        var success = _store.ContainsKey(typeof(T)) && _store[typeof(T)].ContainsKey(key);
        value = success ? this.Fetch<T>(key) : default(T);
        return success;
    }

    public bool TryInject<T>(string key, Action<T> inject)
    {
        var success = this.TryFetch<T>(key, out T value);
        if (success)
        {
            inject(value);
        }
        return success;
    }       
}

var repository = new Repository();

repository.Store("a", new TableA());
repository.Store("b", new TableB());
repository.Store("c", new TableC());
repository.Store("d", new TableD());

/* Somewhere else in your code */
TableA a = repository.Fetch<TableA>("a");
TableB b = repository.Fetch<TableB>("b");
TableC c = repository.Fetch<TableC>("c");
TableD d = repository.Fetch<TableD>("d");

var repository=newrepository（）；
Store（“a”，新表a（））；
Store（“b”，新TableB（））；
Store（“c”，新表c（））；
Store（“d”，newtabled（））；
/*代码中的其他地方*/
TableA a=repository.Fetch（“a”）；
TableB=repository.Fetch（“b”）；
TableC c=repository.Fetch（“c”）；
TableD d=repository.Fetch（“d”）；

关键值（即“a”）是可选的-您可以从代码中删除它-但是如果您需要存储多个特定类型的对象，它非常有用。
这是一个非常简单的解决方案：
List
您可能需要使
tableClass
通用=>
公共静态类tableClass
，但这样我就不能启用多个类型tableInstance。您应该回答您的问题，以澄清您实际希望如何使用
tableClass
。如果需要类级别的泛型字段/属性，则需要一个泛型类。您需要告诉编译器
T
应该是什么类型。如果您希望能够将不同类型的对象添加到列表中，
T
必须是所有这些对象的通用类型，例如
object
。不需要的解决方案似乎是您可能拥有的唯一解决方案。简单地说，如果您希望能够将列表与各种表对象一起使用，您要么需要一个不使用泛型的基类型，要么需要使用object而不是t。在任何一种情况下，您都无法在编译时访问列表中的类型（例如列表的i'th elements Tables'类型），所以，你选择走哪条路其实并不重要。动态的词语被切断了。我希望不是浪费你的时间，可以帮助别人。