c# - 创建一个通用类池，您可以在其中提供通用参数并获取使用该参数的通用对象

Question

目标

我有一个通用类 GenericClass<T>我想共享实例。
我有兴趣看看我是否可以获得语法:

MyGenericPool = new GenericPool<GenericClass>();
// Or maybe it's MyGenericPool = new GenericPool<GenericClass<>>();

GenericClass<TGenericParam> GenericClassInstance =
    MyGenericPool.Get<TGenericParam>();

^{(我对泛型的理解是，不，我不能，别傻了语法不存在/不会工作，但我对其他人的想法很感兴趣)。}

---

展示我的作品

根据我对类型的理解，我有点怀疑 GenericClass<string>和 GenericClass<int>从类型系统的角度来看，它们并没有真正相关。

现在，我意识到我可以接近，即:

GenericClass<TGenericParam> GenericClassInstance =
    GenericPool.Get<GenericClass<TGenericParam>>();

然后有 GenericPool只需存储一个 Dictionary<Type, ObjectPool<object>>某处。
我想看看我是否可以避免这样做。我不想每次都指定泛型类型，作为调用者，我只是更改泛型类型参数。我还希望能够强制执行(编译时)所有对象进入我的 GenericObjectPool<T>是一组通用类型 ( T<> )。

---

我认为问题源于无法将泛型类型参数视为泛型本身。如果我能做到这一点(我已经可以了吗？？)那么也许像下面这样的东西可能会起作用:

public class GenericClassPool<TGeneric> where TGeneric : class<>
{
    private readonly Dictionary<Type, object> objectPools = new Dictionary<Type, object>();


    private void EnsureObjectPoolExists<TGenericParam>()
    {
        if (!objectPools.ContainsKey(typeof(TGenericParam)))
        {
            objectPools.Add(typeof(TGenericParam), new ObjectPool<TGeneric<TGenericParam>>(() => Activator.CreateInstance(typeof(TGeneric<TGenericParam>)) as TGeneric<TGenericParam>));
        }
    }

    private ObjectPool<TGeneric<TGenericParam>> GetPool<TGenericParam>()
    {
        EnsureObjectPoolExists<TGenericParam>();
        return (objectPools[typeof(TGenericParam)] as ObjectPool<TGeneric<TGenericParam>>);
    }

    public void Add<TTypeParam>(TGeneric<TGenericParam> obj)
    {
        EnsureObjectPoolExists<TTypeParam>();

        GetPool<TGenericParam>().Add(obj);
    }

    public TGeneric<TGenericParam> Get<TGenericParam>()
    {
        return GetPool<TGenericParam>().Get() as TGeneric<TGenericParam>;
    }
}

---

问题

我能得到我想要的语法吗(在顶部)？如果不是，我能接近多远？

Answer 1

您尝试实现的解决方案/语法不会那样工作，因为您不能使用没有其类型参数的泛型类型作为另一个泛型类型的类型参数。

但是，您可以使用以下方法获得类似的结果:

1. 为需要您提供完整泛型类型的类池创建一个基类
2. 为特定泛型创建派生类

类似的东西:

public class ObjectPool
{
    Dictionary<Type, object> _objectPool = new Dictionary<Type, object>();

    public void Add<TKey, TValue>(TValue value)
    {
        _objectPool.Add(typeof(TKey), value);
    }

    public TValue Get<TKey, TValue>() where TValue : class
    {
        object value;
        if(_objectPool.TryGetValue(typeof(TKey), out value))
            return value as TValue;
        return null;
    }
}

public class GenericClassPool : ObjectPool
{
    public void Add<TGenericParam>(GenericClass<TGenericParam> obj)
    {
        Add<TGenericParam, GenericClass<TGenericParam>>(obj);
    }

    public GenericClass<TGenericParam> Get<TGenericParam>()
    {
        return Get<TGenericParam, GenericClass<TGenericParam>>();
    }
}

用法是这样的:

var pool = new GenericClassPool();
pool.Add(new GenericClass<string> { Property = "String" });
pool.Add(new GenericClass<int> { Property  = 0 });

GenericClass<string> firstObject = pool.Get<string>();
GenericClass<int> secondObject = pool.Get<int>();

此解决方案的缺点是您需要为每个要池化的泛型类型创建一个池类，因此您可能会有很多 <className>Pool派生自 ObjectPool 的类.
为了使其可用，所有真实代码都需要在 ObjectPool 中类，并且只有提供通用参数的代码保留在派生类中。