Question

我试图通过使用缓存来限制内存中的对象来提高性能。

这会导致我的ObservableCollection出现问题。嗯，我认为代码说明了一切。我已经将我的ObservableCollection衍生物“转化”为：

public class TrackCollection : INotifyPropertyChanged, IEnumerable {
    private readonly List<Guid> _guids = new List<Guid>();

    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(String info) {
        if (PropertyChanged != null) {
            PropertyChanged(this, new PropertyChangedEventArgs(info));
        }
    }

    public void Add(Track track) {
        _guids.Add(track.Id);
    }

    public void Add(Guid trackId) {
        _guids.Add(trackId);
    }

    public IEnumerator GetEnumerator() {
        var tracks = new List<Track>(_guids.Count);
        foreach(Guid id in _guids)
            tracks.Add(MediaCache.Instance.GetTrack(id));

        return tracks.GetEnumerator();
    }
}

当我调用Add-methods时，我想在自己的课程上调用我的NotifyPropertyChanged。

我觉得这是解决这类问题的错误方法，感觉就像是一种解决方法。

无论如何，这是正确的解决方案，如果是这样，我该怎么办？

缓存方法如下所示：

    private readonly List<Track> _tracks = new List<Track>();
    public Track GetTrack(Guid id) {
        foreach (var track in _tracks.Where(track => track.Id == id))
            return track;

        _tracks.Add(Database.Database.Instance.GetTrack(id));
        return _tracks[_tracks.Count - 1];
    }

Answer 1

如果您希望绑定系统可以观察您的集合，则需要实现INotifyCollectionChanged。这将允许您通知感兴趣的客户您收集的更改。

另一方面，要通知侦听器有关整个类的更改，您可以通知名称传递属性的更改。这将导致所有绑定重新评估源。

我进一步查看了代码，我对你的意图感到困惑。每个枚举都会返回一个全新的集合，它与可观察集合的概念不相符。可观察集合的客户期望其项目的各个实例保持一致，因此他们只需要响应重组，而不是刷新整个列表。你能澄清一下你想要完成的事情吗？

您可以创建一个“引用”类TrackReference并使用标准的ObservableCollection，而不是尝试在集合类中处理缓存。该课程看起来像：

public class TrackReference
{
    private Guid _id;

    public Track Track
    {
        get { return MediaCache.Instance.GetTrack(id); }
    }

    public TrackReference(Track track)
    {
        _id = track.Id;
    }

    public TrackReference(Guid trackId)
    {
        _id = trackId;
    }
}

现在你有一个轻量级的句柄，你可以传递（并在集合中观察），使你可以在准备好时访问完整的Track数据。这也是为UI类添加任何轻量级元数据（轨道名称，也许？）的好地方。

使用缓存类的自定义集合

1 个答案: