C# 如何创建不同类型的对象池？

我正在尝试创建一个对象池，其中包含不同类型的对象

如果我将字符串作为ps参数传递给RetriveFunction（），是否可能； 它应该重新生成一个字符串类型的新对象，还是将其从池中删除

字符串将包含类型的名称

Eg

---

可能吗？

是的，这是可能的。字典是通过O（1）查找存储键值对的便捷方式，

Activator

能够实例化仅在运行时已知的类型：

private IDictionary<string, object> _objectPool;
object RetriveFromPool(string typeName)
{     
    if(_objectPool.ContainsKey(typeName))
    {
        return _objectPool[typename]; // return from the pool
    }
    return Activator.CreateInstance(Type.GetType(typeName)); // Try to create a new object using the default constructor
 }

privateIDictionary\u对象池；
对象检索FromPool（字符串类型名称）
{     
if（_objectPool.ContainsKey（typeName））
{
return _objectPool[typename]；//从池中返回
}
return Activator.CreateInstance（Type.GetType（typeName））；//尝试使用默认构造函数创建新对象
}

但是，作为替代方案（确保编译时类型检查），您可能希望使用泛型来实现这一点：

private IDictionary<Type, object> _objectPool;
public T RetrieveFromPool<T>() where T : new() 
{
  Type type = typeof(T);
  return _objectPool.ContainsKey(type) ? (T)_objectPool[type] : new T();
}

// Update - add a couple of templates for add methods:

public void AddToPool<T>() where T : new
{
  _objectPool[typeof(T)] = new T();
}

public void AddToPool<T>(T poolObject) where T : new
{
  _objectPool[typeof(T)] = poolObject;
}

privateIDictionary\u对象池；
公共T RetrieveFromPool（），其中T:new（）
{
类型=类型（T）；
返回_objectPool.ContainsKey（类型）？（T）_objectPool[type]：new T（）；
}
//更新-为添加方法添加两个模板：
public void addtopol（），其中T:new
{
_objectPool[typeof（T）]=新的T（）；
}
public void addtopol（T poolObject），其中T:new
{
_objectPool[typeof（T）]=poolObject；
}

如果您的类型在compiletime已知，则最好使用泛型：

IDictionary<Type, object> Pool = new Dictionary<Type, object>();

T RetrieveFromPool<T>()
    where T : new()
{
    if (Pool.ContainsKey(typeof(T)))
    {
        return Pool[typeof(T)];
    }

    return Pool[typeof(T)] = new T();
}

IDictionary Pool=new Dictionary（）；
T RetrieveFromPool（）
其中T:new（）
{
if（Pool.ContainsKey（typeof（T）））
{
返回池[类型（T）]；
}
返回池[typeof（T）]=新的T（）；
}

下面是我能想出的使用字符串/反射的最安全的方法：

IDictionary<string, object> Pool = new Dictionary<string, object>();

object RetrieveFromPool(string typeName)
{
    if (Pool.ContainsKey(typeName))
    {
        return Pool[typeName];
    }

    Type type = Type.GetType(typeName);
    if (type == null)
    {
        return null;
    }

    ConstructorInfo ctor = type.GetConstructor(Type.EmptyTypes);
    if (ctor == null)
    {
        return null;
    }

    object obj = ctor.Invoke(new object[0]);
    Pool[typeName] = obj;
    return obj;
}

IDictionary Pool=new Dictionary（）；
对象检索FromPool（字符串类型名称）
{
if（Pool.ContainsKey（typeName））
{
返回池[类型名称]；
}
Type Type=Type.GetType（typeName）；
if（type==null）
{
返回null；
}
ConstructorInfo-ctor=type.GetConstructor（type.EmptyTypes）；
if（ctor==null）
{
返回null；
}
object obj=ctor.Invoke（新对象[0]）；
Pool[typeName]=obj；
返回obj；
}

有可能避免反思吗？@rich.okelly该死的，你一直在窃取我的想法！我们的想法完全一致。不过，您的第一个样品有一个错误。您从不存储新实例化的对象。事实上，第二个也是如此。@Zenexer这是故意的（“错误”，而不是分享想法！）。OP没有说他希望将该方法添加到缓存未命中的池中。好吧，他有另一个答案，以防万一。不过想法不错@您能否提供添加到池中的方法

IDictionary<string, object> Pool = new Dictionary<string, object>();

object RetrieveFromPool(string typeName)
{
    if (Pool.ContainsKey(typeName))
    {
        return Pool[typeName];
    }

    Type type = Type.GetType(typeName);
    if (type == null)
    {
        return null;
    }

    ConstructorInfo ctor = type.GetConstructor(Type.EmptyTypes);
    if (ctor == null)
    {
        return null;
    }

    object obj = ctor.Invoke(new object[0]);
    Pool[typeName] = obj;
    return obj;
}