4

我需要提高我的应用程序的内存性能，我可以看到我有内存碎片问题。

我读过Red Gate 的 Andrew Hunter 的一篇关于大型物体的有趣文章，他推荐的解决方案之一是：

如果大型数据结构需要长期存在，特别是如果它们需要随时间增长，最好的方法就是考虑使用或编写不同的数据结构来存储它们。数组在放入大对象堆之前最多可以包含大约 10,000 个元素，并且可能会导致问题，因此存储 100,000 个条目的一种非常有效的方法可能是存储 10 个数组，每个数组包含 10,000 个元素：没有一个会出现在大对象上堆所以不会发生碎片。这可以写成一个IList子类，这样可以很容易地透明地替换现有代码。

我如何在我的代码中实现他的建议？

我的程序有一个非常复杂的形式（每次打开时都会留下剩余内存的对象。我发现了一个可能是罪魁祸首的复杂列表，我想实施他的建议，看看它是否能解决问题。

4

1 回答 1

5

为此使用 List 有什么问题？这不过是 IList 的实现，您可以自己进行分区。但如果你想透明地做到这一点：

实现 IList （它只是一个接口，没什么特别的。也许我不明白这个问题？）并通过所需大小的数组备份它。然后，您Get()将获取index / sizeOfArrays包含所需项目的数组的 as 索引并返回该数组中的index % sizeOfArrays第 th 项。

为了好玩，因为这是一个懒惰的星期五，我写了一些东西。笔记：

  • 我没有测试它
  • 我无法评论您引用的声称这可能有助于避免内存碎片的正确性，我只是盲目地查看了您的请求
  • 我不知道 List 或任何其他集合是否已经足够聪明，可以做到这一点
  • 我做出了一些可能不适合您的决定（即，如果您现在使用数组，则不能盲目地将其放入代码中。Item例如，查看实现，尤其是 setter

也就是说，这是一个减少我周末前动机不足的起点。我给亲爱的读者（或OP）留下了一些有趣的方法作为练习.. ;-)

public class PartitionList<T> : IList<T> {
    private readonly int _maxCountPerList;
    private readonly IList<IList<T>> _lists;

    public PartitionList(int maxCountPerList) {
        _maxCountPerList = maxCountPerList;
        _lists = new List<IList<T>> { new List<T>() };
    }

    public IEnumerator<T> GetEnumerator() {
        return _lists.SelectMany(list => list).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }

    public void Add(T item) {
        var lastList = _lists[_lists.Count - 1];
        if (lastList.Count == _maxCountPerList) {
            lastList = new List<T>();
            _lists.Add(lastList);
        }
        lastList.Add(item);
    }

    public void Clear() {
        while (_lists.Count > 1) _lists.RemoveAt(1);
        _lists[0].Clear();
    }

    public bool Contains(T item) {
        return _lists.Any(sublist => sublist.Contains(item));
    }

    public void CopyTo(T[] array, int arrayIndex) {
        // Homework
        throw new NotImplementedException();
    }

    public bool Remove(T item) {
        // Evil, Linq with sideeffects
        return _lists.Any(sublist => sublist.Remove(item));
    }

    public int Count {
        get { return _lists.Sum(subList => subList.Count); }
    }

    public bool IsReadOnly {
        get { return false; }
    }

    public int IndexOf(T item) {
        int index = _lists.Select((subList, i) => subList.IndexOf(item) * i).Max();
        return (index > -1) ? index : -1;
    }

    public void Insert(int index, T item) {
        // Homework
        throw new NotImplementedException();
    }

    public void RemoveAt(int index) {
        // Homework
        throw new NotImplementedException();
    }

    public T this[int index] {
        get {
            if (index >= _lists.Sum(subList => subList.Count)) {
                throw new IndexOutOfRangeException();
            }
            var list = _lists[index / _maxCountPerList];
            return list[index % _maxCountPerList];
        }
        set {
            if (index >= _lists.Sum(subList => subList.Count)) {
                throw new IndexOutOfRangeException();
            }
            var list = _lists[index / _maxCountPerList];
            list[index % _maxCountPerList] = value;
        }
    }
}
于 2010-02-12T12:09:22.797 回答