using System;

using System.Collections.Concurrent;

​

public class Program

{

    public static void Main()

    {

        var pool = new ObjectPool<string>(() => "", maxSize: 2);

​

        using (var obj = pool.Get())

        {

            int hashCode = obj.Do(e => e.GetHashCode());

        }

    }

}

​

public class ObjectPool<T>

{

    private readonly ConcurrentBag<T> m_objects = new ConcurrentBag<T>();

    private readonly Func<T> m_objectGenerator;

    private int m_counter = 0;

    private readonly int m_maxSize;

​

    public ObjectPool(Func<T> objectGenerator, int maxSize)

    {

        m_objectGenerator = objectGenerator ?? throw new ArgumentNullException(nameof(objectGenerator));

        m_maxSize = maxSize;

    }

    private T GetImpl()

    {

        if (m_objects.TryTake(out T item))

        {

            m_counter--;

            return item;

        }

        else

        {

            T obj = m_objectGenerator();

            m_objects.Add(obj);

            m_counter++;

            return obj;

        }

    }

​

    public PoolObject<T> Get() => new PoolObject<T>(this, GetImpl());

​

    public void PutObject(T item)

    {

        if (m_counter < m_maxSize)

        {

            m_objects.Add(item);

            m_counter++;

        }           

    }

}

​

​

public sealed class PoolObject<T> : IDisposable

{

    private ObjectPool<T> m_objectPool;

    private T m_value;

    public PoolObject(ObjectPool<T> pool, T value)

    {

        m_objectPool = pool;

        m_value = value;

    }

​

    void IDisposable.Dispose()

    {

        m_objectPool.PutObject(m_value);

    }

    public void Do(Action<T> action)

    {

        action(m_value);

    }

    public TResult Do<TResult>(Func<T, TResult> action)

    {

        return action(m_value);

    }

}

​