Question

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

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);
}

我无法更改表<T>，这是一个nuget包类。

我该如何实现？我尝试过的所有方法都行不通（将T类型设置为class，使用object代替T进行强制类型转换-不需要解决方案）。

有人可以帮我吗？

Answer 1

TablesClass不是泛型类，您没有告诉编译器T应该位于什么类型。

如果您希望能够将不同种类的对象添加到同一IList<Tables<T>>列表中，则T 必须是所有这些对象的通用基本类型。

例如，如果您希望能够将苹果，梨和香蕉添加到列表中，则以T为基础，可以将类型参数Fruit指定为Fruit所有这些类型的类。

很显然，如果您希望能够访问列表中某个特定于Fruit类的具体实现的项目的任何成员，则需要从Fruit进行强制转换，但这是不可避免的。您不会将一堆不同种类的水果扔到一个篮子里，并期望总是能够捡起特定的水果，对吗？

Answer 2

您的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
{
    //...
}

然后您的课程必须是：

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);
    }
}

然后您可以像这样使用它：

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

Answer 3

如果要执行这种操作，则需要使用object来保存引用，但是要使用一种允许使用强类型存储和获取每个表的方法。

尝试这样的课程：

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");

键值（即“ a”）是可选的-您可以将其从代码中删除-但如果您需要存储一个以上特定类型的对象，则很有用。

Answer 4

简单得多的解决方案：List<dynamic>。

实例化通用列表

4 个答案: