优化C＃代码片段，ObservableCollection和AddRange

Question

我正在分析其他人编写的silverlight组件。 我发现很多热点和瓶颈，现在我碰到这一个：

public static class CollectionExtensions 
{ 
    public static void AddRange<T>(this ObservableCollection<T> collection, IEnumerable<T> items) 
    { 
     foreach (var item in items) 
     { 
      collection.Add(item); 
     } 
    } 
} 

这种扩展方法，当然的AddRange方法添加到一个ObservableCollection，但它的计算相当密集。 有没有人有更好的执行，或者有关如何提高这块cose性能的任何建议？

谢谢

Answer 1

多次调用Add会导致INotifyCollectionChanged多次引发，导致UI重绘自身。

尽管Lee的回答在技术上是正确的，即在添加所有项目后提升Reset事件是正确的方法，但我从经验中发现，许多网格控件（例如）不主动支持Reset事件。

最普遍支持的选项是将集合修改为远离ObservableCollection并重新创建ObservableCollection属性本身。

与定义在VM如下您ObservableCollection换句话说...

private ObservableCollection<MyItem> _items; 
public ObservableCollection<MyItem> Items { 
    get { return _items;} 
    set 
    { 
     _items = value; 
     OnPropertyChanged(()=> Items); 
    } 
} 

...添加新的项目如下...

var tempColl = _items.ToList(); 
tempColl.AddRange(newItems); 
Items = new ObservableCollection(tempColl); 

另一件事来承担关于这种技术的想法是它是线程安全的，因为如果重新创建ObservableCollection，您可以从后台线程向ObservableCollection添加项目。正常ObservableCollection不能通过非Dispatcher线程的Add方法将项添加到它。

Answer 2

成本一般在这里是因为这是提高了每个单独添加更改通知。最好做的是创建一个新的集合实现，该集合实现为接受数据范围而优化。不必为每个更改引发更改通知，然后将绑定引擎处理为单个更新，您可以添加所有值，然后引发单个事件。此事件可以使大锤子为Reset，或者您可以提供已更改的项目以及其更改的索引。

这是其AddRange方法是使用一个Reset通知的例子：

/// <summary> 
/// An implementation of <seealso cref="ObservableCollection{T}"/> that provides the ability to suppress 
/// change notifications. In sub-classes that allows performing batch work and raising notifications 
/// on completion of work. Standard usage takes advantage of this feature by providing AddRange method. 
/// </summary> 
/// <typeparam name="T">The type of elements in the list.</typeparam> 
public class ObservableList<T> : ObservableCollection<T> 
{ 
    #region Fields 
    private readonly Queue<PropertyChangedEventArgs> _notifications = new Queue<PropertyChangedEventArgs>(); 
    private readonly Queue<NotifyCollectionChangedEventArgs> _collectionNotifications = new Queue<NotifyCollectionChangedEventArgs>(); 
    private int _notificationSupressionDepth; 
    #endregion 

    public ObservableList() 
    { 
    } 
    public ObservableList(IEnumerable<T> collection) 
     : base(collection) 
    { 
    } 

    public void AddRange(IEnumerable<T> list) 
    { 
     using (SupressNotifications()) 
     { 
      foreach (var item in list) 
      { 
       Add(item); 
      } 
     } 
     OnPropertyChanged("Count"); 
     OnPropertyChanged("Item[]"); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 

    public void RemoveRange(IEnumerable<T> list) 
    { 
     using (SupressNotifications()) 
     { 
      foreach (var item in list) 
      { 
       Remove(item); 
      } 
     } 
     OnPropertyChanged("Count"); 
     OnPropertyChanged("Item[]"); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 

    public void ReplaceRange(IEnumerable<T> list) 
    { 
     using (SupressNotifications()) 
     { 
      Clear(); 
      foreach (var item in list) 
      { 
       Add(item); 
      } 
     } 
     OnPropertyChanged("Count"); 
     OnPropertyChanged("Item[]"); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 


    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) 
    { 
     if (_notificationSupressionDepth == 0) 
     { 
      base.OnCollectionChanged(e); 
     } 
     else 
     { 
      //We cant filter duplicate Collection change events as this will break how UI controls work. -LC 
      _collectionNotifications.Enqueue(e); 
     } 
    } 

    protected override void OnPropertyChanged(PropertyChangedEventArgs e) 
    { 
     if (_notificationSupressionDepth == 0) 
     { 
      base.OnPropertyChanged(e); 
     } 
     else 
     { 
      if (!_notifications.Contains(e, NotifyEventComparer.Instance)) 
      { 
       _notifications.Enqueue(e); 
      } 
     } 
    } 

    protected void OnPropertyChanged(string propertyName) 
    { 
     OnPropertyChanged(new PropertyChangedEventArgs(propertyName)); 
    } 

    protected IDisposable QueueNotifications() 
    { 
     _notificationSupressionDepth++; 
     return Disposable.Create(() => 
            { 
             _notificationSupressionDepth--; 
             TryNotify(); 
            }); 
    } 

    protected IDisposable SupressNotifications() 
    { 
     _notificationSupressionDepth++; 
     return Disposable.Create(() => 
     { 
      _notificationSupressionDepth--; 
     }); 
    } 

    private void TryNotify() 
    { 
     if (_notificationSupressionDepth == 0) 
     { 
      while (_collectionNotifications.Count > 0) 
      { 
       var collectionNotification = _collectionNotifications.Dequeue(); 
       base.OnCollectionChanged(collectionNotification); 
      } 

      while (_notifications.Count > 0) 
      { 
       var notification = _notifications.Dequeue(); 
       base.OnPropertyChanged(notification); 
      } 
     } 
    } 
} 

编辑：添加缺少的NotifyEventComparer类和实例Disposable.Create方法

public sealed class NotifyEventComparer : IEqualityComparer<PropertyChangedEventArgs> 
{ 
    public static readonly NotifyEventComparer Instance = new NotifyEventComparer(); 

    bool IEqualityComparer<PropertyChangedEventArgs>.Equals(PropertyChangedEventArgs x, PropertyChangedEventArgs y) 
    { 
     return x.PropertyName == y.PropertyName; 
    } 

    int IEqualityComparer<PropertyChangedEventArgs>.GetHashCode(PropertyChangedEventArgs obj) 
    { 
     return obj.PropertyName.GetHashCode(); 
    } 
} 

//Either use Rx to access Disposable.Create or this simple implementation will do 
public static class Disposable 
{ 
    public static IDisposable Create(Action dispose) 
    { 
     if (dispose == null) 
      throw new ArgumentNullException("dispose"); 

     return new AnonymousDisposable(dispose); 
    } 

    private sealed class AnonymousDisposable : IDisposable 
    { 
     private Action _dispose; 

     public AnonymousDisposable(Action dispose) 
     { 
      _dispose = dispose; 
     } 

     public void Dispose() 
     { 
      var dispose = Interlocked.Exchange(ref _dispose, null); 
      if (dispose != null) 
      { 
       dispose(); 
      } 
     } 
    } 
} 

Answer 3

你可以看到的AddRange这里的方法实现（对于列表）： http://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs

Answer 4

这是由于ObservableCollection在每次将项目添加到集合时触发PropertyChanged事件。在批量添加项目时防止此事件发生是您想要查看的内容。这是一个优雅的解决方案，尽管我自己并没有尝试过。

https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/