ObjectPool & lt; T & gt; ou similaire pour .NET déjà dans une bibliothèque?

Mise à JOUR:

J'avais aussi mis de l'avant type bufferblock<T> de TPL DataFlow. Autant que je me souvienne c'est une partie de .net maintenant. La grande chose au sujet BufferBlock<T> est que vous pouvez attendre de manière asynchrone pour les articles deviennent disponibles à l'aide de la Post<T> et ReceiveAsync<T> les méthodes d'extension. Très pratique dans un async/await monde.

RÉPONSE ORIGINALE À CETTE QUESTION

Un temps, j'ai été confronté à ce problème et est venu avec un léger (rough n'ready) thread-safe (je l'espère) de la piscine qui s'est révélée très utile, réutilisable et robuste:

    public class Pool<T> where T : class
{
private readonly Queue<AsyncResult<T>> asyncQueue = new Queue<AsyncResult<T>>();
private readonly Func<T> createFunction;
private readonly HashSet<T> pool;
private readonly Action<T> resetFunction;
public Pool(Func<T> createFunction, Action<T> resetFunction, int poolCapacity)
{
this.createFunction = createFunction;
this.resetFunction = resetFunction;
pool = new HashSet<T>();
CreatePoolItems(poolCapacity);
}
public Pool(Func<T> createFunction, int poolCapacity) : this(createFunction, null, poolCapacity)
{
}
public int Count
{
get
{
return pool.Count;
}
}
private void CreatePoolItems(int numItems)
{
for (var i = 0; i < numItems; i++)
{
var item = createFunction();
pool.Add(item);
}
}
public void Push(T item)
{
if (item == null)
{
Console.WriteLine("Push-ing null item. ERROR");
throw new ArgumentNullException();
}
if (resetFunction != null)
{
resetFunction(item);
}
lock (asyncQueue)
{
if (asyncQueue.Count > 0)
{
var result = asyncQueue.Dequeue();
result.SetAsCompletedAsync(item);
return;
}
}
lock (pool)
{
pool.Add(item);
}
}
public T Pop()
{
T item;
lock (pool)
{
if (pool.Count == 0)
{
return null;
}
item = pool.First();
pool.Remove(item);
}
return item;
}
public IAsyncResult BeginPop(AsyncCallback callback)
{
var result = new AsyncResult<T>();
result.AsyncCallback = callback;
lock (pool)
{
if (pool.Count == 0)
{
lock (asyncQueue)
{
asyncQueue.Enqueue(result);
return result;
}
}
var poppedItem = pool.First();
pool.Remove(poppedItem);
result.SetAsCompleted(poppedItem);
return result;
}
}
public T EndPop(IAsyncResult asyncResult)
{
var result = (AsyncResult<T>) asyncResult;
return result.EndInvoke();
}
}

Afin d'éviter toute interface exigences de la mise en commun des objets, à la fois la création et la réinitialisation des objets est effectuée par l'utilisateur fourni délégués: c'est à dire

Pool<MemoryStream> msPool = new Pool<MemoryStream>(() => new MemoryStream(2048), pms => {
pms.Position = 0;
pms.SetLength(0);
}, 500);

Dans le cas où la piscine est vide, le BeginPop/EndPop paire de fournir un APM (ish) des moyens de récupération de l'objet de manière asynchrone lorsqu'il est disponible (à l'aide de Jeff Richter excellent AsyncResult<TResult> mise en œuvre).

Je ne me souviens pas pourquoi il est constained à T : classe... il n'y a probablement aucun.

CodeProject dispose d'un échantillon ObjectPool mise en œuvre. Jetez un oeil ici. Sinon, il y a quelques implémentations iciiciet ici.

Sonne comme vous avez besoin d'un modèle de Fabrique avec la mise en cache.

Vous pouvez essayer de l'utiliser .net réflecteur à regarder le pool de threads mise en œuvre.