Install-Package Collections.Pooled
dotnet add package Collections.Pooled
paket add Collections.Pooled

using Collections.Pooled;
// 使用方式是一樣的
var list = new List<int>();
var pooledList = new PooledList<int>();
var dictionary = new Dictionary<int,int>();
var pooledDictionary = new PooledDictionary<int,int>();
// 包括PooledSet、PooledQueue、PooledStack的使用方法都是一樣的
var pooledList1 = Enumerable.Range(0,100).ToPooledList();
var pooledDictionary1 = Enumerable.Range(0,100).ToPooledDictionary(i => i, i => i);

using Collections.Pooled;
// 使用using var 會在pooled對象使用完畢后自動釋放
using var pooledList = new PooledList<int>();
Console.WriteLine(pooledList.Count);
// 使用using作用域 作用域結(jié)束以后就會釋放
using (var pooledDictionary = new PooledDictionary<int, int>())
{
	Console.WriteLine(pooledDictionary.Count);
}
// 手動調(diào)用Dispose方法
var pooledStack = new PooledStack<int>();
Console.WriteLine(pooledStack.Count);
pooledList.Dispose();

namespace Collections.Pooled
{
    /// <summary>
    /// 這個枚舉允許控制在內(nèi)部數(shù)組返回到ArrayPool時如何處理數(shù)據(jù)。
    /// 數(shù)組返回到ArrayPool時如何處理數(shù)據(jù)。在使用默認選項之外的其他選項之前，請注意了解 
    /// 在使用默認值A(chǔ)uto之外的任何其他選項之前，請仔細了解每個選項的作用。
    /// </summary>
    public enum ClearMode
    {
        /// <summary>
        /// <para><code>Auto</code>根據(jù)目標(biāo)框架有不同的行為</para>
        /// <para>.NET Core 2.1: 引用類型和包含引用類型的值類型在內(nèi)部數(shù)組返回池時被清除。 不包含引用類型的值類型在返回池時不會被清除。</para>
        /// <para>.NET Standard 2.0: 在返回池之前清除所有用戶類型，以防它們包含引用類型。 對于 .NET Standard，Auto 和 Always 具有相同的行為。</para>
        /// </summary>
        Auto = 0,
        
        /// <summary>
        /// The <para><code>Always</code> 設(shè)置的效果是在返回池之前總是清除用戶類型。
        /// </summary>
        Always = 1,
        
        /// <summary>
        /// <para><code>Never</code> 將導(dǎo)致池化集合在將它們返回池之前永遠不會清除用戶類型。</para>
        /// </summary>
        Never = 2
    }
}

private static readonly string[] List = Enumerable  
    .Range(0, 10000).Select(c => c.ToString()).ToArray();  
// 使用默認的集合類型  
[Benchmark(Baseline = true)]  
public int UseList()  
{  
    var list = new List<string>(1024);  
    for (var index = 0; index < List.Length; index++)  
    {  
        var item = List[index];  
        list.Add(item);  
    }  
    return list.Count;  
}  
// 使用PooledList 并且及時釋放  
[Benchmark]  
public int UsePooled()  
{  
    using var list = new PooledList<string>(1024);  
    for (var index = 0; index < List.Length; index++)  
    {  
        var item = List[index];  
        list.Add(item);  
    }  
    return list.Count;  
}  
// 使用PooledList 不釋放  
[Benchmark]  
public int UsePooledWithOutUsing()  
{  
    var list = new PooledList<string>(1024);  
    for (var index = 0; index < List.Length; index++)  
    {  
        var item = List[index];  
        list.Add(item);  
    }  
    return list.Count;  
}

public List(int capacity)
{
      if (capacity < 0)
          ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);

      if (capacity == 0)
          _items = s_emptyArray;
      else
          _items = new T[capacity];
}

// 默認使用ArrayPool<T>.Shared池
public PooledList(int capacity, ClearMode clearMode, bool sizeToCapacity) : this(capacity, clearMode, ArrayPool<T>.Shared, sizeToCapacity) { }  

// 分配數(shù)組使用 ArrayPool
public PooledList(int capacity, ClearMode clearMode, ArrayPool<T> customPool, bool sizeToCapacity)
{
    if (capacity < 0)
        ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
    _pool = customPool ?? ArrayPool<T>.Shared;
    _clearOnFree = ShouldClear(clearMode);
    if (capacity == 0)
    {
        _items = s_emptyArray;
    }
    else
    {
        _items = _pool.Rent(capacity);
    }
    
    if (sizeToCapacity)
    {
        _size = capacity;
        if (clearMode != ClearMode.Never)
        {
            Array.Clear(_items, 0, _size);
        }
    }
 }

public int Capacity
{
    get => _items.Length;
    set
    {
        if (value < _size)
        {
            ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity);
        }

        if (value != _items.Length)
        {
            if (value > 0)
            {
                // 從池中分配數(shù)組
                var newItems = _pool.Rent(value);
                if (_size > 0)
                {
                    Array.Copy(_items, newItems, _size);
                }
                // 舊數(shù)組歸還到池中
                ReturnArray();
                _items = newItems;
            }
            else
            {
                ReturnArray();
                _size = 0;
            }
        }
    }
}
private void ReturnArray()  
{  
    if (_items.Length == 0)  
        return;  
    try  
    {  
        // 歸還到池中
        _pool.Return(_items, clearArray: _clearOnFree);  
    }  
    catch (ArgumentException)  
    {  
        // ArrayPool可能會拋出異常，我們直接吞掉 
    }  
    _items = s_emptyArray;  
}