c# - 维护内存的可重用列表

Question

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

我的目标是在内存池中使用这个类，所以我希望内存得到维护，但让调用者使用这个类，就好像它是一个标准列表一样，但要避免大量的内存重新分配。

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

这是我希望在 .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 .你可以看看source code你自己。例如，这里是 Clear 方法:

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

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