Disposable Pool

gistfile1.txt

using System;

namespace Pools
{
    public abstract class GenericPool<T> : IDisposable where T : class
    {
        public abstract void Dispose();

        private T _instance;

        public T Instance => _instance ?? (_instance = CreateInstance());

        protected abstract T CreateInstance();

        public override string ToString()
        {
            return Instance.ToString();
        }
    }
}


using System.Collections.Concurrent;
using System.Text;

namespace Pools
{
    public sealed class StringBuilderPool : GenericPool<StringBuilder>
    {
        private StringBuilderPool()
        {
        }

        private static readonly ConcurrentQueue<StringBuilderPool> _queue = new ConcurrentQueue<StringBuilderPool>();

        public static StringBuilderPool Get()
        {
            if(_queue.IsEmpty || _queue.TryDequeue(out var instance) == false)
            {
                instance = new StringBuilderPool();
            }

            return instance;
        }

        public override void Dispose()
        {
            Instance.Clear();
            _queue.Enqueue(this);
        }

        protected override StringBuilder CreateInstance()
        {
            return new StringBuilder();
        }
    }
}


Usage:

using(var sbp = StringBuilderPool.Get())
{
}