Creazione di un pool di classi generico in cui si dà il parametro generico e ottieni un oggetto generico che utilizzava quel parametro

Question

Obiettivo

Ho una classe generica GenericClass<T> E voglio mettere in riunione le istanze.
Mi interessa vedere se riesco a ottenere la sintassi:

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

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

^{(La mia comprensione dei generici dice, no, non posso, non essere sciocco la sintassi non esiste / non funzionerei, ma sono inteso in ciò che pensano gli altri).}

---

Mostrando i miei meccanismi

Sono un po 'dubbio come dalla mia comprensione dei tipi GenericClass<string> e GenericClass<int> non sono realmente correlati dal punto di vista del sistema di tipo.

Ora, mi rendo conto di potermi avvicinare, cioè:

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

e poi avere il GenericPool Basta conservare a Dictionary<Type, ObjectPool<object>> in qualche luogo.
Sono interessato a vedere se posso evitare di doverlo fare. Non voglio specificare il tipo generico ogni volta che, come chiamante, sto solo modificando il parametro di tipo generico. Mi piacerebbe anche essere in grado di imporre (compilare tempo) che tutti gli oggetti che entrano nel mio GenericObjectPool<T> sono di tipo generico set (T<>).

---

Penso che il problema derivi dal non essere in grado di trattare un parametro di tipo generico come generico. Se potessi farlo (posso già ??) allora forse qualcosa di simile potrebbe funzionare:

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

---

Domanda

Posso ottenere la sintassi che voglio (in alto)? In caso contrario, quanto posso avvicinarmi?