6

我是多线程和 WPF 的新手。

我有一个ObservableCollection<RSSFeed>, 在应用程序启动项从 UI 线程添加到此集合。RSSFeed 的属性绑定到 WPF ListView。稍后，我想异步更新每个 RSSFeed。所以我正在考虑实现类似的东西RSSFeed.FetchAsync()并在其更新的属性上提高 PropertyChanged 。

我知道 ObservableCollection 不支持来自 UI 线程以外的线程的更新，它会抛出 NotSupportedException。但是由于我不是在操作 ObservableCollection 本身，而是在更新其项目的属性，所以我可以期望它能够工作并看到更新的 ListView 项目吗？还是会由于 PropertyChanged 而引发异常？

编辑：代码

RSSFeed.cs 

public class RSSFeed
{
    public String Title { get; set; }
    public String Summary { get; set; }
    public String Uri { get; set; }        
    public String Encoding { get; set; }
    public List<FeedItem> Posts { get; set; }
    public bool FetchedSuccessfully { get; protected set; }        

    public RSSFeed()
    {
        Posts = new List<FeedItem>();
    }

    public RSSFeed(String uri)
    {
        Posts = new List<FeedItem>();
        Uri = uri;
        Fetch();
    }

    public void FetchAsync()
    { 
        // call Fetch asynchronously
    }

    public void Fetch()
    {
        if (Uri != "")
        {
            try
            {
                MyWebClient client = new MyWebClient();
                String str = client.DownloadString(Uri);

                str = Regex.Replace(str, "<!--.*?-->", String.Empty, RegexOptions.Singleline);
                FeedXmlReader reader = new FeedXmlReader();
                RSSFeed feed = reader.Load(str, new Uri(Uri));

                if (feed.Title != null)
                    Title = feed.Title;
                if (feed.Encoding != null)
                    Encoding = feed.Encoding;
                if (feed.Summary != null)
                    Summary = feed.Summary;
                if (feed.Posts != null)
                    Posts = feed.Posts;

                FetchedSuccessfully = true;
            }
            catch
            {
                FetchedSuccessfully = false;
            }

        }
    }

用户配置文件.cs

public class UserProfile : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    public event CollectionChangeEventHandler CollectionChanged;

    private ObservableCollection<RSSFeed> feeds;
    public ObservableCollection<RSSFeed> Feeds 
    { 
        get { return feeds; }
        set { feeds = value; OnPropertyChanged("Feeds"); }
    }

    public UserProfile()
    {
        feeds = new ObservableCollection<RSSFeed>();
    }

    protected void OnPropertyChanged(string name)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(name));
        }
    }

    protected void OnCollectionChanged(RSSFeed feed)
    {
        CollectionChangeEventHandler handler = CollectionChanged;
        if (handler != null)
        {
            handler(this, new CollectionChangeEventArgs(CollectionChangeAction.Add, feed));
        }
    }
}

主窗口.xaml.cs

public partial class MainWindow : Window, INotifyPropertyChanged
{
    // My ListView is bound to this
    // ItemsSource="{Binding Posts}
    public List<FeedItem> Posts
    {
        get 
        {
            if (listBoxChannels.SelectedItem != null)
                return ((RSSFeed)listBoxChannels.SelectedItem).Posts;
            else
                return null;
        }
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        // here I load cached feeds
        // called from UI thread

        // now I want to update the feeds
        // since network operations are involved, 
        // I need to do this asynchronously to prevent blocking the UI thread
    }

}

谢谢。

4

6 回答 6

5

使用 .Net 4.5，您可以使用 BindingOperations.EnableCollectionSynchronization 添加对后台线程更新到 ObservableCollection 的支持。这适用于 MVVM。

请参阅： .net 4.0 等效的 BindingOperations.EnableCollectionSynchronization()

于 2013-09-15T19:52:23.633 回答
3

对于这种应用程序，我通常使用将 ReportsProgress 设置为 True 的 BackgroundWorker。然后，您可以为每个调用传递一个对象作为 ReportProgress 方法中的 userState 参数。ProgressChanged 事件将在 UI 线程上运行，因此您可以将对象添加到事件处理程序中的 ObservableCollection。

否则，从后台线程更新属性将起作用，但如果您正在过滤或排序 ObservableCollection，则除非引发某些集合更改通知事件，否则不会重新应用过滤器。

您可以通过查找集合中项目的索引（例如，通过将其报告为progresspercentage）并设置list.item(i) = e.userstate 来重新应用过滤器和排序，即自行替换列表中的项目在 ProgressChanged 事件中。这样，绑定到集合的任何控件的 SelectedItem 都将被保留，而过滤和排序将尊重项目中任何更改的值。

于 2012-05-09T16:38:45.250 回答
3

如果您使用的是 WPF，您可以更新单个绑定项目的属性并从后台线程引发 PropertyChanged。WPF 数据绑定机制（与 WinForms 等效机制不同）检测到这一点并为您编组到 UI 线程。这当然是有代价的——使用自动机制，每个单独的属性更新都会导致一个编组事件，所以如果你要更改很多属性，性能可能会受到影响，你应该考虑将自己的 UI 编组为单个批处理操作.

但是，您不允许操作集合（添加/删除项目），因此如果您的 RSS 提要包含要绑定到的嵌套集合，则需要提前将整个更新提升到 UI 线程。

于 2012-05-09T15:08:58.257 回答
1

我有一个类似的场景，遇到了这个“ObservableCollection 不支持来自 UI 线程以外的线程的更新”，最后通过在 Thomas Levesque 的博客中引用这个AsyncObservableCollection 实现得到了解决，我认为它可能对你有帮助。

在其更新版本中，SynchronizationContext 用于解决此问题。可以参考SynchronizationContext的MSDN页面

于 2013-12-04T02:29:45.803 回答
1

您可能想查看 .Net 中的 ConcurrentCollections 命名空间。

http://msdn.microsoft.com/en-us/library/system.collections.concurrent.aspx

这是另一个可能也有帮助的问题。

ObservableCollection 和线程

于 2012-05-09T16:37:44.930 回答
0

这是一个简单的 observablecollection，它在 AddRange 方法结束时通知，基于这篇文章https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/

根据这篇文章https://thomaslevesque.com/2009/04/17/wpf-binding-to-an-asynchronous-collection/ ，它也是异步和跨线程可修改的

public class ConcurrentObservableCollection<T> : ObservableCollection<T>
{
    private SynchronizationContext _synchronizationContext = SynchronizationContext.Current;

    private bool _suppressNotification = false;

    public ConcurrentObservableCollection()
        : base()
    {
    }
    public ConcurrentObservableCollection(IEnumerable<T> list)
        : base(list)
    {
    }

    public void AddRange(IEnumerable<T> collection)
    {
        if (collection != null)
        {
            _suppressNotification = true;
            foreach (var item in collection)
            {
                this.Add(item);
            }
            _suppressNotification = false;

            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
    }
    public void RemoveRange(IEnumerable<T> collection)
    {
        if (collection != null)
        {
            _suppressNotification = true;
            foreach (var item in collection)
            {
                this.Remove(item);
            }
            _suppressNotification = false;

            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (SynchronizationContext.Current == _synchronizationContext)
        {
            // Execute the CollectionChanged event on the current thread
            RaiseCollectionChanged(e);
        }
        else
        {
            // Raises the CollectionChanged event on the creator thread
            _synchronizationContext.Send(RaiseCollectionChanged, e);
        }
    }
    protected override void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        if (SynchronizationContext.Current == _synchronizationContext)
        {
            // Execute the PropertyChanged event on the current thread
            RaisePropertyChanged(e);
        }
        else
        {
            // Raises the PropertyChanged event on the creator thread
            _synchronizationContext.Send(RaisePropertyChanged, e);
        }
    }

    private void RaiseCollectionChanged(object param)
    {
        // We are in the creator thread, call the base implementation directly
        if (!_suppressNotification)
            base.OnCollectionChanged((NotifyCollectionChangedEventArgs)param);
    }
    private void RaisePropertyChanged(object param)
    {
        // We are in the creator thread, call the base implementation directly
        base.OnPropertyChanged((PropertyChangedEventArgs)param);
    }
}
于 2021-11-01T14:58:02.183 回答