维护内存的可重用列表

Question

>我正在寻找 .NET 中的 List<T> 类型类，它的行为类似于 List<T>，但在调用 Clear() 时不会取消分配其内存 - 仅重置 Size 属性。

我的目标是在内存池中使用此类，因此我希望维护内存，但让调用方使用该类，就好像它是标准列表一样，但要避免大量内存重新分配。

如果这已经存在，请告诉我，因为它将节省优化、测试和调试此代码的时间。

以下是我希望在 .NET 库中找到的内容的模型：

public class ReusableList<T>
{
    #region Static Properties
    private static long InitialCapacity = 1000000;
    private static int CapacityIncreaseRate = 10000;
    #endregion
    #region Properties
    public long Size
    {
        get
        {
            return this._size;
        }
        private set
        {
            this._size = 0;
        }
    }
    private long _size = 0;
    private long RealSize
    {
        get
        {
            return this._realSize;
        }
        set
        {
            this._realSize = value;
        }
    }
    private long _realSize = 0;
    private T[] Data
    {
        set
        {
            this._data = value;
        }
        get
        {
            return this._data;
        }
    }
    private T[] _data = null;
    #endregion
    #region Operators
    public T this[long index]
    {
        get
        {
            return this.Data[index];
        }
        set
        {
            this.Data[index] = value;
        }
    }
    #endregion
    #region Public Methods
    public ReusableList()
    {
        this.Rebuild();
    }
    public void Add(T item)
    {
        this.Data[this.Size] = item;
        this._size++;
        if (this.Size >= this.RealSize)
        {
            this.IncreaseSizeOfList();
        }
    }
    public void Clear()
    {
        this.Size = 0;
    }
    #endregion
    #region Private Methods
    private void Rebuild()
    {
        this.Data = null;
        this.Data = new T[ReusableList<T>.InitialCapacity];
        this.Size = 0;
        this.RealSize = ReusableList<T>.InitialCapacity;
    }
    private void IncreaseSizeOfList()
    {
        if (this.Size < this.RealSize)
            return;
        var newData = new T[this.RealSize + ReusableList<T>.CapacityIncreaseRate];
        Array.Copy(this.Data, newData, this.RealSize);
        this.Data = newData;
        this.RealSize += ReusableList<T>.CapacityIncreaseRate;
    }
    #endregion
}

Answer 1

据

我了解，这是List<T>的默认行为。

当您将项目添加到列表时，它会根据需要分配新内存。当您删除项目（甚至根本不清除列表）时，它既不会"释放"内存，也不会减小内部数组的大小。

减少

内部数组的唯一方法是减少Capacity。您可以自己查看源代码。例如，这是Clear方法：

public void Clear() 
{
    if (_size > 0)
    {
        Array.Clear(_items, 0, _size);
        _size = 0;
    }
    _version++;
}

如您所见，这里仅将数组项设置为默认值，并将大小设置为 0。

Answer 2

您可以存储内部列表的备份。

public class ReusableList<T> : List<T>
{
    private List<T> backup;
    public void Clear(bool purge)
    {
        if (purge)
            backup?.Clear();
        else
            backup = this.ToList();
        base.Clear();
    }
    public new void Clear()
    {
        this.Clear(false);
    }
}