如何最好地向上传播更改通知以进行绑定的分层结构？

Question

如果我有一个类似文件夹的结构，使用 复合设计模式 并且我绑定根文件夹到 TreeView。如果我可以显示从文件夹内容中积累的某些属性，那将非常有用。问题是，如何最好地通知文件夹子元素中发生的更改，以便更新累积属性？

我需要这个的上下文是我正在尝试制作的一个小型 RSS-FeedReader。这是我的模型中最重要的对象和方面：

复合接口：

public interface IFeedComposite : INotifyPropertyChanged
{
    string Title { get; set; }

    int UnreadFeedItemsCount { get; }

    ObservableCollection<FeedItem> FeedItems { get; }
}

FeedComposite（又名文件夹）

public class FeedComposite : BindableObject, IFeedComposite
    {
        private string title = "";
        public string Title
        {
            get { return title; }
            set
            {
                title = value;
                NotifyPropertyChanged("Title");
            }
        }

        private ObservableCollection<IFeedComposite> children = new ObservableCollection<IFeedComposite>();
        public ObservableCollection<IFeedComposite> Children
        {
            get { return children; }
            set
            {
                children.Clear();
                foreach (IFeedComposite item in value)
                {
                    children.Add(item);
                }
                NotifyPropertyChanged("Children");
            }
        }

        public FeedComposite() { }

        public FeedComposite(string title)
        {
            Title = title;
        }

        public ObservableCollection<FeedItem> FeedItems
        {
            get
            {
                ObservableCollection<FeedItem> feedItems = new ObservableCollection<FeedItem>();
                foreach (IFeedComposite child in Children)
                {
                    foreach (FeedItem item in child.FeedItems)
                    {
                        feedItems.Add(item);
                    }
                }
                return feedItems;
            }
        }


    public int UnreadFeedItemsCount
    {
        get
        {
            return (from i in FeedItems
                    where i.IsUnread
                    select i).Count();
        }
    }

Feed：

public class Feed : BindableObject, IFeedComposite
    {
        private string url = "";
        public string Url
        {
            get { return url; }
            set
            {
                url = value;
                NotifyPropertyChanged("Url");
            }
        }

        ...


        private ObservableCollection<FeedItem> feedItems = new ObservableCollection<FeedItem>();
        public ObservableCollection<FeedItem> FeedItems
        {
            get { return feedItems; }
            set
            {
                feedItems.Clear();
                foreach (FeedItem item in value)
                {
                    AddFeedItem(item);
                }
                NotifyPropertyChanged("Items");
            }
        }

        public int UnreadFeedItemsCount
        {
            get
            {
                return (from i in FeedItems
                        where i.IsUnread
                        select i).Count();
            }
        }

        public Feed() { }

        public Feed(string url)
        {
            Url = url;
        }

好的，这就是问题，如果我绑定一个 TextBlock.Text< /code> 到 UnreadFeedItemsCount 当项目被标记为未读时，不会有简单的通知，因此我的方法之一是处理每个 PropertyChanged 事件>FeedItem 并且如果 IsUnread-Property 发生更改，我会让我的 Feed 发出属性 UnreadFeedItemsCount 已更改的通知。通过这种方法，我还需要处理 的 Children 中所有 Feeds 和 FeedComposites 的所有 PropertyChanged 事件FeedComposite，从它的声音来看，很明显这不是一个很好的主意，您需要非常小心，在没有附加 的情况下，永远不要将项目添加到任何集合或从任何集合中删除首先是 PropertyChanged 事件处理程序。

另外：我该如何处理 CollectionChanged - 必然也会导致未读项目计数总和发生变化的事件？听起来事件处理更有趣。

真是一团糟；如果有人对此有一个优雅的解决方案，那就太好了，因为我不希望提要阅读器最终像我几年前的第一次尝试一样糟糕，当时我什至不知道数据绑定......

Answer 1

好吧，我想我应该尝试一下你的问题，看看我会想出什么。它未经测试，并且与您已经拥有的有点相同。我所做的主要区别是添加了处理提要的添加和删除的方法，这些提要处理其工作所需的事件绑定。有一些代码，所以这里，

我的所有代码都在一个文件中，如果您想在单独的文件中，则需要稍微修改。

首先是 PropertyChangedEventHandler 的常规扩展方法
你不需要使用它，但我非常喜欢它。

public static class NotifyPropertyChangedExtention
    {
        public static void Raise<T, TP>(this PropertyChangedEventHandler pc, T source, Expression<Func<T, TP>> pe)
        {
            if (pc != null)
            {
                pc.Invoke(source, new PropertyChangedEventArgs(((MemberExpression)pe.Body).Member.Name));
            }
        }
    }

其次，FeedItem 减去提要内容:) 我有一个检查，仅当值实际更改时才引发更改事件。您可以看到此处使用的 Raise 扩展方法，没有字符串，很可爱。

class FeedItem : INotifyPropertyChanged
{
    private bool _isUnread;
    public event PropertyChangedEventHandler PropertyChanged;

    public bool IsUnread
    {
        get { return _isUnread; }
        set
        {
            if (_isUnread != value)
            {
                _isUnread = value;
                PropertyChanged.Raise(this, x => x.IsUnread);
            }
        }
    }
}

现在，我的界面略有不同，因为我的文件夹可以包含其他文件夹以及提要。

internal interface IFeedComposite : INotifyPropertyChanged
{
    string Title { get; set; }
    int UnreadFeedItemsCount { get; }
}

internal interface IFeedFolder : IFeedComposite
{
    ObservableCollection<IFeedFolder> FeedFolders { get; }
    ObservableCollection<IFeed> Feeds { get; }
    void AddFeed(IFeed newFeed);
    void RemoveFeed(IFeed feedToRemove);
    void AddFeedFolder(IFeedFolder newFeedFolder);
    void RemoveFeedFolder(IFeedFolder feedFolderToRemove);
}

internal interface IFeed : IFeedComposite
{
    ObservableCollection<FeedItem> FeedItems { get; }
    void AddFeedItem(FeedItem newFeedItem);
    void RemoveFeedItem(FeedItem feedItemToRemove);
}

现在，Feed 类的 AddFeedItem 方法会为您挂钩属性更改事件，如果它被标记为未读，则会引发计数的属性更改事件。您可以重载此方法，以接受项目列表，然后将它们添加到列表后（如果有未读的地方），为所有项目引发一个属性更改事件。

class Feed : IFeed
{
    private readonly ObservableCollection<FeedItem> _feedItems = new ObservableCollection<FeedItem>();

    public event PropertyChangedEventHandler PropertyChanged;
    public string Title { get; set; }

    public int UnreadFeedItemsCount
    {
        get
        {
            return (from i in FeedItems
                    where i.IsUnread
                    select i).Count();
        }
    }

    public ObservableCollection<FeedItem> FeedItems
    {
        get { return _feedItems; }
    }

    public void AddFeedItem(FeedItem newFeed)
    {
        newFeed.PropertyChanged += NewFeedPropertyChanged;
        _feedItems.Add(newFeed);
        PropertyChanged.Raise(this, x => x.FeedItems);
        if (newFeed.IsUnread)
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }

    public void RemoveFeedItem(FeedItem feedToRemove)
    {
        _feedItems.Remove(feedToRemove);
        PropertyChanged.Raise(this, x => x.FeedItems);
        if (feedToRemove.IsUnread)
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }

    void NewFeedPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "IsUnread")
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }
}

现在，FeedFolder 类与 feed 类非常相似，但是这个类可以保存 feed 列表和 feed 文件夹列表（保存它们自己的 feed）。如果需要，您可以轻松添加方法或属性来返回源和源文件夹中的所有源项目。同样，各种检查仅在需要时引发更改事件。

class FeedFolder : IFeedFolder
{
    private readonly ObservableCollection<IFeedFolder> _feedFolders = new ObservableCollection<IFeedFolder>();
    private readonly ObservableCollection<IFeed> _feeds = new ObservableCollection<IFeed>();

    public event PropertyChangedEventHandler PropertyChanged;
    public string Title { get; set; }

    public int UnreadFeedItemsCount
    {
        get { return Feeds.Sum(x => x.UnreadFeedItemsCount) + FeedFolders.Sum(x => x.UnreadFeedItemsCount); }
    }

    public ObservableCollection<IFeedFolder> FeedFolders
    {
        get { return _feedFolders; }
    }

    public ObservableCollection<IFeed> Feeds
    {
        get { return _feeds; }
    }

    public void AddFeed(IFeed newFeed)
    {
        newFeed.PropertyChanged += NewFeedPropertyChanged;
        _feeds.Add(newFeed);
        PropertyChanged.Raise(this, x => x.Feeds);
        if (newFeed.UnreadFeedItemsCount > 0)
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }

    void NewFeedPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "UnreadFeedItemsCount")
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }

    public void RemoveFeed(IFeed feedToRemove)
    {
        _feeds.Remove(feedToRemove);
        PropertyChanged.Raise(this, x => x.Feeds);
        if (feedToRemove.UnreadFeedItemsCount > 0)
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }

    public void AddFeedFolder(IFeedFolder newFeedFolder)
    {
        newFeedFolder.PropertyChanged += NewFeedPropertyChanged;
        _feedFolders.Add(newFeedFolder);
        PropertyChanged.Raise(this, x => x.FeedFolders);
        if (newFeedFolder.UnreadFeedItemsCount > 0)
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }

    public void RemoveFeedFolder(IFeedFolder feedFolderToRemove)
    {
        _feedFolders.Remove(feedFolderToRemove);
        PropertyChanged.Raise(this, x => x.FeedFolders);
        if (feedFolderToRemove.UnreadFeedItemsCount > 0)
        {
            PropertyChanged.Raise(this, x => x.UnreadFeedItemsCount);
        }
    }
}

现在就使用而言，请记住我还没有对此进行测试，但它应该大部分是正确的。

var myFolder = new FeedFolder();
var myFeed = new Feed();
var myFeedItem = new FeedItem();
myFeedItem.IsUnread = true;
myFeed.AddFeedItem(myFeedItem);
myFolder.AddFeed(myFeed);

var mySecondFeedItem = new FeedItem();

//add a second feeditem to feed, but it is marked as read, so no notifications raised for unread count.
myFeed.AddFeedItem(mySecondFeedItem);

//this should fire off change events all the way up to the folder
mySecondFeedItem.IsUnread = true;