Question

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

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

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

这是我希望在.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>的默认行为。

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

减少内部数组的唯一方法是减少Capacity。您可以自己查看source code。例如，这里的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);
    }
}

保持内存的可重用列表

2 个答案: