Observer ableCollection 不支持 AddRange 方法，所以每添加一个条目我都会收到通知，除了 INotifyCollectionChange 之外呢？

小开

请参阅升级和优化的 C # 7版本。我不想删除 VB.NET 版本，所以我只是在一个单独的答案中发布了它。

转到最新版本

似乎不支持，我自己实现的，仅供参考，希望能有所帮助:

我更新了 VB 版本，从现在开始，在更改集合之前会引发一个事件，这样你就可以后悔(在使用 DataGrid、 ListView和其他更多功能时，你可以向用户显示一个“ Are you sure”确认) ，更新的 VB 版本在此消息的底部。

请接受我的道歉，屏幕太窄，容纳不了我的代码，我也不喜欢它。

VB.NET:

Imports System.Collections.Specialized


Namespace System.Collections.ObjectModel
''' <summary>
''' Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed.
''' </summary>
''' <typeparam name="T"></typeparam>
Public Class ObservableRangeCollection(Of T) : Inherits System.Collections.ObjectModel.ObservableCollection(Of T)


''' <summary>
''' Adds the elements of the specified collection to the end of the ObservableCollection(Of T).
''' </summary>
Public Sub AddRange(ByVal collection As IEnumerable(Of T))
For Each i In collection
Items.Add(i)
Next
OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))
End Sub


''' <summary>
''' Removes the first occurence of each item in the specified collection from ObservableCollection(Of T).
''' </summary>
Public Sub RemoveRange(ByVal collection As IEnumerable(Of T))
For Each i In collection
Items.Remove(i)
Next


OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))
End Sub


''' <summary>
''' Clears the current collection and replaces it with the specified item.
''' </summary>
Public Sub Replace(ByVal item As T)
ReplaceRange(New T() {item})
End Sub
''' <summary>
''' Clears the current collection and replaces it with the specified collection.
''' </summary>
Public Sub ReplaceRange(ByVal collection As IEnumerable(Of T))
Dim old = Items.ToList
Items.Clear()
For Each i In collection
Items.Add(i)
Next
OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))
End Sub


''' <summary>
''' Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class.
''' </summary>
''' <remarks></remarks>
Public Sub New()
MyBase.New()
End Sub
''' <summary>
''' Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class that contains elements copied from the specified collection.
''' </summary>
''' <param name="collection">collection: The collection from which the elements are copied.</param>
''' <exception cref="System.ArgumentNullException">The collection parameter cannot be null.</exception>
Public Sub New(ByVal collection As IEnumerable(Of T))
MyBase.New(collection)
End Sub
End Class


End Namespace

C # :

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;


/// <summary>
/// Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed.
/// </summary>
/// <typeparam name="T"></typeparam>
public class ObservableRangeCollection<T> : ObservableCollection<T>
{
/// <summary>
/// Adds the elements of the specified collection to the end of the ObservableCollection(Of T).
/// </summary>
public void AddRange(IEnumerable<T> collection)
{
if (collection == null) throw new ArgumentNullException("collection");


foreach (var i in collection) Items.Add(i);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}


/// <summary>
/// Removes the first occurence of each item in the specified collection from ObservableCollection(Of T).
/// </summary>
public void RemoveRange(IEnumerable<T> collection)
{
if (collection == null) throw new ArgumentNullException("collection");


foreach (var i in collection) Items.Remove(i);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}


/// <summary>
/// Clears the current collection and replaces it with the specified item.
/// </summary>
public void Replace(T item)
{
ReplaceRange(new T[] { item });
}


/// <summary>
/// Clears the current collection and replaces it with the specified collection.
/// </summary>
public void ReplaceRange(IEnumerable<T> collection)
{
if (collection == null) throw new ArgumentNullException("collection");


Items.Clear();
foreach (var i in collection) Items.Add(i);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}


/// <summary>
/// Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class.
/// </summary>
public ObservableRangeCollection()
: base() { }


/// <summary>
/// Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class that contains elements copied from the specified collection.
/// </summary>
/// <param name="collection">collection: The collection from which the elements are copied.</param>
/// <exception cref="System.ArgumentNullException">The collection parameter cannot be null.</exception>
public ObservableRangeCollection(IEnumerable<T> collection)
: base(collection) { }
}

更新-可观测范围集合与集合更改通知

Imports System.Collections.Specialized
Imports System.ComponentModel
Imports System.Collections.ObjectModel


Public Class ObservableRangeCollection(Of T) : Inherits ObservableCollection(Of T) : Implements INotifyCollectionChanging(Of T)
''' <summary>
''' Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class.
''' </summary>
''' <remarks></remarks>
Public Sub New()
MyBase.New()
End Sub


''' <summary>
''' Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class that contains elements copied from the specified collection.
''' </summary>
''' <param name="collection">collection: The collection from which the elements are copied.</param>
''' <exception cref="System.ArgumentNullException">The collection parameter cannot be null.</exception>
Public Sub New(ByVal collection As IEnumerable(Of T))
MyBase.New(collection)
End Sub


''' <summary>
''' Adds the elements of the specified collection to the end of the ObservableCollection(Of T).
''' </summary>
Public Sub AddRange(ByVal collection As IEnumerable(Of T))
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Add, collection)
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


Dim index = Items.Count - 1
For Each i In collection
Items.Add(i)
Next


OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, collection, index))
End Sub




''' <summary>
''' Inserts the collection at specified index.
''' </summary>
Public Sub InsertRange(ByVal index As Integer, ByVal Collection As IEnumerable(Of T))
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Add, Collection)
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


For Each i In Collection
Items.Insert(index, i)
Next


OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))
End Sub




''' <summary>
''' Removes the first occurence of each item in the specified collection from ObservableCollection(Of T).
''' </summary>
Public Sub RemoveRange(ByVal collection As IEnumerable(Of T))
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Remove, collection)
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


For Each i In collection
Items.Remove(i)
Next


OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))
End Sub






''' <summary>
''' Clears the current collection and replaces it with the specified item.
''' </summary>
Public Sub Replace(ByVal item As T)
ReplaceRange(New T() {item})
End Sub


''' <summary>
''' Clears the current collection and replaces it with the specified collection.
''' </summary>
Public Sub ReplaceRange(ByVal collection As IEnumerable(Of T))
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Replace, Items)
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


Items.Clear()
For Each i In collection
Items.Add(i)
Next
OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))
End Sub


Protected Overrides Sub ClearItems()
Dim e As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Reset, Items)
OnCollectionChanging(e)


If e.Cancel Then Exit Sub


MyBase.ClearItems()
End Sub


Protected Overrides Sub InsertItem(ByVal index As Integer, ByVal item As T)
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Add, item)
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


MyBase.InsertItem(index, item)
End Sub


Protected Overrides Sub MoveItem(ByVal oldIndex As Integer, ByVal newIndex As Integer)
Dim ce As New NotifyCollectionChangingEventArgs(Of T)()
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


MyBase.MoveItem(oldIndex, newIndex)
End Sub


Protected Overrides Sub RemoveItem(ByVal index As Integer)
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Remove, Items(index))
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


MyBase.RemoveItem(index)
End Sub


Protected Overrides Sub SetItem(ByVal index As Integer, ByVal item As T)
Dim ce As New NotifyCollectionChangingEventArgs(Of T)(NotifyCollectionChangedAction.Replace, Items(index))
OnCollectionChanging(ce)
If ce.Cancel Then Exit Sub


MyBase.SetItem(index, item)
End Sub


Protected Overrides Sub OnCollectionChanged(ByVal e As Specialized.NotifyCollectionChangedEventArgs)
If e.NewItems IsNot Nothing Then
For Each i As T In e.NewItems
If TypeOf i Is INotifyPropertyChanged Then AddHandler DirectCast(i, INotifyPropertyChanged).PropertyChanged, AddressOf Item_PropertyChanged
Next
End If
MyBase.OnCollectionChanged(e)
End Sub


Private Sub Item_PropertyChanged(ByVal sender As T, ByVal e As ComponentModel.PropertyChangedEventArgs)
OnCollectionChanged(New NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset, sender, IndexOf(sender)))
End Sub


Public Event CollectionChanging(ByVal sender As Object, ByVal e As NotifyCollectionChangingEventArgs(Of T)) Implements INotifyCollectionChanging(Of T).CollectionChanging
Protected Overridable Sub OnCollectionChanging(ByVal e As NotifyCollectionChangingEventArgs(Of T))
RaiseEvent CollectionChanging(Me, e)
End Sub
End Class




Public Interface INotifyCollectionChanging(Of T)
Event CollectionChanging(ByVal sender As Object, ByVal e As NotifyCollectionChangingEventArgs(Of T))
End Interface


Public Class NotifyCollectionChangingEventArgs(Of T) : Inherits CancelEventArgs


Public Sub New()
m_Action = NotifyCollectionChangedAction.Move
m_Items = New T() {}
End Sub


Public Sub New(ByVal action As NotifyCollectionChangedAction, ByVal item As T)
m_Action = action
m_Items = New T() {item}
End Sub


Public Sub New(ByVal action As NotifyCollectionChangedAction, ByVal items As IEnumerable(Of T))
m_Action = action
m_Items = items
End Sub


Private m_Action As NotifyCollectionChangedAction
Public ReadOnly Property Action() As NotifyCollectionChangedAction
Get
Return m_Action
End Get
End Property


Private m_Items As IList
Public ReadOnly Property Items() As IEnumerable(Of T)
Get
Return m_Items
End Get
End Property
End Class

小开

您必须小心地将 UI 绑定到您的自定义集合—— Default CollectionView 类只支持项的单个通知。

小开

是的，添加您自己的自定义可观察收藏将是足够公平的。不要忘记引发适当的事件，无论它是否被 UI 暂时使用;)你必须引发“ Item []”属性的属性更改通知(WPF 端和绑定控件需要) ，以及 NotifyCollectionChangedEventArgs 添加了一组项目(你的范围)。我已经做了这些事情(以及排序支持和其他一些事情) ，并且在表示层和代码隐藏层都没有问题。

小开

我认为 AddRange 的实现方式更好:

public void AddRange(IEnumerable<T> collection)
{
foreach (var i in collection) Items.Add(i);
OnCollectionChanged(
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}

它可以为您节省一份列表副本。此外，如果你想微优化，你可以做添加多达 N 项，如果超过 N 项添加了一个复位。

小开

这里给出了一些关于集合更改和 UI 问题的额外帮助:

小开

证明需要 OnPropertyChanged("Count")和 OnPropertyChanged("Item[]")调用，以便按照 ObservableCollection的行为。请注意，我不知道什么后果，如果你不打扰！

下面是一个测试方法，它显示在一个正常的可观察集合中，每个 add 都有两个 PropertyChange 事件。一个是 "Count"一个是 "Item[]"。

[TestMethod]
public void TestAddSinglesInOldObsevableCollection()
{
int colChangedEvents = 0;
int propChangedEvents = 0;
var collection = new ObservableCollection<object>();
collection.CollectionChanged += (sender, e) => { colChangedEvents++; };
(collection as INotifyPropertyChanged).PropertyChanged += (sender, e) => { propChangedEvents++; };
collection.Add(new object());
collection.Add(new object());
collection.Add(new object());
Assert.AreEqual(3, colChangedEvents);
Assert.AreEqual(6, propChangedEvents);
}

@ Shimmy，将标准替换为您的集合，并更改为一个加法范围，您将得到零 PropertyChanges。请注意，集合更改的确可以正常工作，但是不能完全做到观察集合所做的事情。因此，测试摆振集合看起来像这样:

[TestMethod]
public void TestShimmyAddRange()
{
int colChangedEvents = 0;
int propChangedEvents = 0;
var collection = new ShimmyObservableCollection<object>();
collection.CollectionChanged += (sender, e) => { colChangedEvents++; };
(collection as INotifyPropertyChanged).PropertyChanged += (sender, e) => { propChangedEvents++; };
collection.AddRange(new[]{
new object(), new object(), new object(), new object()}); //4 objects at once
Assert.AreEqual(1, colChangedEvents);  //great, just one!
Assert.AreEqual(2, propChangedEvents); //fails, no events :(
}

仅供参考，以下是来自 Observer ableCollection 的 InsertItem (也由 Add 调用)代码:

protected override void InsertItem(int index, T item)
{
base.CheckReentrancy();
base.InsertItem(index, item);
base.OnPropertyChanged("Count");
base.OnPropertyChanged("Item[]");
base.OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
}

小开

您还可以使用这段代码来扩展 Observer ableCollection:

public static class ObservableCollectionExtend
{
public static void AddRange<TSource>(this ObservableCollection<TSource> source, IEnumerable<TSource> items)
{
foreach (var item in items)
{
source.Add(item);
}
}
}

那么您就不需要更改现有代码中的类。

小开

由于可能有许多操作要在一个 Observer ableCollection 上执行，例如，先清除，然后添加范围，然后为一个 ComboBox 插入“ All”项，我最终得到以下解决方案:

public static class LinqExtensions
{
public static ICollection<T> AddRange<T>(this ICollection<T> source, IEnumerable<T> addSource)
{
foreach(T item in addSource)
{
source.Add(item);
}


return source;
}
}


public class ExtendedObservableCollection<T>: ObservableCollection<T>
{
public void Execute(Action<IList<T>> itemsAction)
{
itemsAction(Items);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
}

并举例说明如何使用它:

MyDogs.Execute(items =>
{
items.Clear();
items.AddRange(Context.Dogs);
items.Insert(0, new Dog { Id = 0, Name = "All Dogs" });
});

只有在执行完成对基础列表的处理之后，才会调用 Reset 通知。

小开

C # 总结了后代。

public sealed class ObservableCollectionEx<T> : ObservableCollection<T>
{
#region Ctor


public ObservableCollectionEx()
{
}


public ObservableCollectionEx(List<T> list) : base(list)
{
}


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


#endregion


/// <summary>
/// Adds the elements of the specified collection to the end of the ObservableCollection(Of T).
/// </summary>
public void AddRange(
IEnumerable<T> itemsToAdd,
ECollectionChangeNotificationMode notificationMode = ECollectionChangeNotificationMode.Add)
{
if (itemsToAdd == null)
{
throw new ArgumentNullException("itemsToAdd");
}
CheckReentrancy();


if (notificationMode == ECollectionChangeNotificationMode.Reset)
{
foreach (var i in itemsToAdd)
{
Items.Add(i);
}


OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));


return;
}


int startIndex = Count;
var changedItems = itemsToAdd is List<T> ? (List<T>) itemsToAdd : new List<T>(itemsToAdd);
foreach (var i in changedItems)
{
Items.Add(i);
}


OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, changedItems, startIndex));
}


public enum ECollectionChangeNotificationMode
{
/// <summary>
/// Notifies that only a portion of data was changed and supplies the changed items (not supported by some elements,
/// like CollectionView class).
/// </summary>
Add,


/// <summary>
/// Notifies that the entire collection was changed, does not supply the changed items (may be inneficient with large
/// collections as requires the full update even if a small portion of items was added).
/// </summary>
Reset
}
}

小开

Observer ableRangeCollection 应该通过如下测试

[Test]
public void TestAddRangeWhileBoundToListCollectionView()
{
int collectionChangedEventsCounter = 0;
int propertyChangedEventsCounter = 0;
var collection = new ObservableRangeCollection<object>();


collection.CollectionChanged += (sender, e) => { collectionChangedEventsCounter++; };
(collection as INotifyPropertyChanged).PropertyChanged += (sender, e) => { propertyChangedEventsCounter++; };


var list = new ListCollectionView(collection);


collection.AddRange(new[] { new object(), new object(), new object(), new object() });


Assert.AreEqual(4, collection.Count);
Assert.AreEqual(1, collectionChangedEventsCounter);
Assert.AreEqual(2, propertyChangedEventsCounter);
}

否则

System.NotSupportedException : Range actions are not supported.

同时与控件一起使用。

我没有看到一个理想的解决方案，但 NotifyCollectionChangedAction。重置而不是添加/删除部分解决问题。请参见 net _ prog 提到的 http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx

小开

下面是对已接受答案的修改，以提供更多功能。

Rangecollection.cs :

public class RangeCollection<T> : ObservableCollection<T>
{
#region Members


/// <summary>
/// Occurs when a single item is added.
/// </summary>
public event EventHandler<ItemAddedEventArgs<T>> ItemAdded;


/// <summary>
/// Occurs when a single item is inserted.
/// </summary>
public event EventHandler<ItemInsertedEventArgs<T>> ItemInserted;


/// <summary>
/// Occurs when a single item is removed.
/// </summary>
public event EventHandler<ItemRemovedEventArgs<T>> ItemRemoved;


/// <summary>
/// Occurs when a single item is replaced.
/// </summary>
public event EventHandler<ItemReplacedEventArgs<T>> ItemReplaced;


/// <summary>
/// Occurs when items are added to this.
/// </summary>
public event EventHandler<ItemsAddedEventArgs<T>> ItemsAdded;


/// <summary>
/// Occurs when items are removed from this.
/// </summary>
public event EventHandler<ItemsRemovedEventArgs<T>> ItemsRemoved;


/// <summary>
/// Occurs when items are replaced within this.
/// </summary>
public event EventHandler<ItemsReplacedEventArgs<T>> ItemsReplaced;


/// <summary>
/// Occurs when entire collection is cleared.
/// </summary>
public event EventHandler<ItemsClearedEventArgs<T>> ItemsCleared;


/// <summary>
/// Occurs when entire collection is replaced.
/// </summary>
public event EventHandler<CollectionReplacedEventArgs<T>> CollectionReplaced;


#endregion


#region Helper Methods


/// <summary>
/// Throws exception if any of the specified objects are null.
/// </summary>
private void Check(params T[] Items)
{
foreach (T Item in Items)
{
if (Item == null)
{
throw new ArgumentNullException("Item cannot be null.");
}
}
}


private void Check(IEnumerable<T> Items)
{
if (Items == null) throw new ArgumentNullException("Items cannot be null.");
}


private void Check(IEnumerable<IEnumerable<T>> Items)
{
if (Items == null) throw new ArgumentNullException("Items cannot be null.");
}


private void RaiseChanged(NotifyCollectionChangedAction Action)
{
this.OnPropertyChanged(new PropertyChangedEventArgs("Count"));
this.OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}


#endregion


#region Bulk Methods


/// <summary>
/// Adds the elements of the specified collection to the end of this.
/// </summary>
public void AddRange(IEnumerable<T> NewItems)
{
this.Check(NewItems);
foreach (var i in NewItems) this.Items.Add(i);
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
this.OnItemsAdded(new ItemsAddedEventArgs<T>(NewItems));
}


/// <summary>
/// Adds variable IEnumerable<T> to this.
/// </summary>
/// <param name="List"></param>
public void AddRange(params IEnumerable<T>[] NewItems)
{
this.Check(NewItems);
foreach (IEnumerable<T> Items in NewItems) foreach (T Item in Items) this.Items.Add(Item);
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
//TO-DO: Raise OnItemsAdded with combined IEnumerable<T>.
}


/// <summary>
/// Removes the first occurence of each item in the specified collection.
/// </summary>
public void Remove(IEnumerable<T> OldItems)
{
this.Check(OldItems);
foreach (var i in OldItems) Items.Remove(i);
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
OnItemsRemoved(new ItemsRemovedEventArgs<T>(OldItems));
}


/// <summary>
/// Removes all occurences of each item in the specified collection.
/// </summary>
/// <param name="itemsToRemove"></param>
public void RemoveAll(IEnumerable<T> OldItems)
{
this.Check(OldItems);
var set = new HashSet<T>(OldItems);
var list = this as List<T>;
int i = 0;
while (i < this.Count) if (set.Contains(this[i])) this.RemoveAt(i); else i++;
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
OnItemsRemoved(new ItemsRemovedEventArgs<T>(OldItems));
}


/// <summary>
/// Replaces all occurences of a single item with specified item.
/// </summary>
public void ReplaceAll(T Old, T New)
{
this.Check(Old, New);
this.Replace(Old, New, false);
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
this.OnItemReplaced(new ItemReplacedEventArgs<T>(Old, New));
}


/// <summary>
/// Clears this and adds specified collection.
/// </summary>
public void ReplaceCollection(IEnumerable<T> NewItems, bool SupressEvent = false)
{
this.Check(NewItems);
IEnumerable<T> OldItems = new List<T>(this.Items);
this.Items.Clear();
foreach (T Item in NewItems) this.Items.Add(Item);
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
this.OnReplaced(new CollectionReplacedEventArgs<T>(OldItems, NewItems));
}


private void Replace(T Old, T New, bool BreakFirst)
{
List<T> Cloned = new List<T>(this.Items);
int i = 0;
foreach (T Item in Cloned)
{
if (Item.Equals(Old))
{
this.Items.Remove(Item);
this.Items.Insert(i, New);
if (BreakFirst) break;
}
i++;
}
}


/// <summary>
/// Replaces the first occurence of a single item with specified item.
/// </summary>
public void Replace(T Old, T New)
{
this.Check(Old, New);
this.Replace(Old, New, true);
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
this.OnItemReplaced(new ItemReplacedEventArgs<T>(Old, New));
}


#endregion


#region  New Methods


/// <summary>
/// Removes a single item.
/// </summary>
/// <param name="Item"></param>
public new void Remove(T Item)
{
this.Check(Item);
base.Remove(Item);
OnItemRemoved(new ItemRemovedEventArgs<T>(Item));
}


/// <summary>
/// Removes a single item at specified index.
/// </summary>
/// <param name="i"></param>
public new void RemoveAt(int i)
{
T OldItem = this.Items[i]; //This will throw first if null
base.RemoveAt(i);
OnItemRemoved(new ItemRemovedEventArgs<T>(OldItem));
}


/// <summary>
/// Clears this.
/// </summary>
public new void Clear()
{
IEnumerable<T> OldItems = new List<T>(this.Items);
this.Items.Clear();
this.RaiseChanged(NotifyCollectionChangedAction.Reset);
this.OnCleared(new ItemsClearedEventArgs<T>(OldItems));
}


/// <summary>
/// Adds a single item to end of this.
/// </summary>
/// <param name="t"></param>
public new void Add(T Item)
{
this.Check(Item);
base.Add(Item);
this.OnItemAdded(new ItemAddedEventArgs<T>(Item));
}


/// <summary>
/// Inserts a single item at specified index.
/// </summary>
/// <param name="i"></param>
/// <param name="t"></param>
public new void Insert(int i, T Item)
{
this.Check(Item);
base.Insert(i, Item);
this.OnItemInserted(new ItemInsertedEventArgs<T>(Item, i));
}


/// <summary>
/// Returns list of T.ToString().
/// </summary>
/// <returns></returns>
public new IEnumerable<string> ToString()
{
foreach (T Item in this) yield return Item.ToString();
}


#endregion


#region Event Methods


private void OnItemAdded(ItemAddedEventArgs<T> i)
{
if (this.ItemAdded != null) this.ItemAdded(this, new ItemAddedEventArgs<T>(i.NewItem));
}


private void OnItemInserted(ItemInsertedEventArgs<T> i)
{
if (this.ItemInserted != null) this.ItemInserted(this, new ItemInsertedEventArgs<T>(i.NewItem, i.Index));
}


private void OnItemRemoved(ItemRemovedEventArgs<T> i)
{
if (this.ItemRemoved != null) this.ItemRemoved(this, new ItemRemovedEventArgs<T>(i.OldItem));
}


private void OnItemReplaced(ItemReplacedEventArgs<T> i)
{
if (this.ItemReplaced != null) this.ItemReplaced(this, new ItemReplacedEventArgs<T>(i.OldItem, i.NewItem));
}


private void OnItemsAdded(ItemsAddedEventArgs<T> i)
{
if (this.ItemsAdded != null) this.ItemsAdded(this, new ItemsAddedEventArgs<T>(i.NewItems));
}


private void OnItemsRemoved(ItemsRemovedEventArgs<T> i)
{
if (this.ItemsRemoved != null) this.ItemsRemoved(this, new ItemsRemovedEventArgs<T>(i.OldItems));
}


private void OnItemsReplaced(ItemsReplacedEventArgs<T> i)
{
if (this.ItemsReplaced != null) this.ItemsReplaced(this, new ItemsReplacedEventArgs<T>(i.OldItems, i.NewItems));
}


private void OnCleared(ItemsClearedEventArgs<T> i)
{
if (this.ItemsCleared != null) this.ItemsCleared(this, new ItemsClearedEventArgs<T>(i.OldItems));
}


private void OnReplaced(CollectionReplacedEventArgs<T> i)
{
if (this.CollectionReplaced != null) this.CollectionReplaced(this, new CollectionReplacedEventArgs<T>(i.OldItems, i.NewItems));
}


#endregion


#region RangeCollection


/// <summary>
/// Initializes a new instance.
/// </summary>
public RangeCollection() : base() { }


/// <summary>
/// Initializes a new instance from specified enumerable.
/// </summary>
public RangeCollection(IEnumerable<T> Collection) : base(Collection) { }


/// <summary>
/// Initializes a new instance from specified list.
/// </summary>
public RangeCollection(List<T> List) : base(List) { }


/// <summary>
/// Initializes a new instance with variable T.
/// </summary>
public RangeCollection(params T[] Items) : base()
{
this.AddRange(Items);
}


/// <summary>
/// Initializes a new instance with variable enumerable.
/// </summary>
public RangeCollection(params IEnumerable<T>[] Items) : base()
{
this.AddRange(Items);
}


#endregion
}

活动类别:

public class CollectionReplacedEventArgs<T> : ReplacedEventArgs<T>
{
public CollectionReplacedEventArgs(IEnumerable<T> Old, IEnumerable<T> New) : base(Old, New) { }
}


public class ItemAddedEventArgs<T> : EventArgs
{
public T NewItem;
public ItemAddedEventArgs(T t)
{
this.NewItem = t;
}
}


public class ItemInsertedEventArgs<T> : EventArgs
{
public int Index;
public T NewItem;
public ItemInsertedEventArgs(T t, int i)
{
this.NewItem = t;
this.Index = i;
}
}


public class ItemRemovedEventArgs<T> : EventArgs
{
public T OldItem;
public ItemRemovedEventArgs(T t)
{
this.OldItem = t;
}
}


public class ItemReplacedEventArgs<T> : EventArgs
{
public T OldItem;
public T NewItem;
public ItemReplacedEventArgs(T Old, T New)
{
this.OldItem = Old;
this.NewItem = New;
}
}


public class ItemsAddedEventArgs<T> : EventArgs
{
public IEnumerable<T> NewItems;
public ItemsAddedEventArgs(IEnumerable<T> t)
{
this.NewItems = t;
}
}


public class ItemsClearedEventArgs<T> : RemovedEventArgs<T>
{
public ItemsClearedEventArgs(IEnumerable<T> Old) : base(Old) { }
}


public class ItemsRemovedEventArgs<T> : RemovedEventArgs<T>
{
public ItemsRemovedEventArgs(IEnumerable<T> Old) : base(Old) { }
}


public class ItemsReplacedEventArgs<T> : ReplacedEventArgs<T>
{
public ItemsReplacedEventArgs(IEnumerable<T> Old, IEnumerable<T> New) : base(Old, New) { }
}


public class RemovedEventArgs<T> : EventArgs
{
public IEnumerable<T> OldItems;
public RemovedEventArgs(IEnumerable<T> Old)
{
this.OldItems = Old;
}
}


public class ReplacedEventArgs<T> : EventArgs
{
public IEnumerable<T> OldItems;
public IEnumerable<T> NewItems;
public ReplacedEventArgs(IEnumerable<T> Old, IEnumerable<T> New)
{
this.OldItems = Old;
this.NewItems = New;
}
}

注意: 我没有在基本方法中手动提高 OnCollectionChanged，因为似乎只有使用 Reset操作才能创建 CollectionChangedEventArgs。如果尝试使用 Reset为单个项目更改引发 OnCollectionChanged，则项目控件将显示为闪烁，这是您希望避免的。

小开

最佳答案

首先，请 投票和评论上的空气污染指数要求上的.NET 回购。

这里是我的优化版本的 ObservableRangeCollection(优化版本的詹姆斯蒙特马尼奥的一)。

它执行速度非常快，意味着在可能的情况下重用现有元素，避免不必要的事件，或者在可能的情况下将它们批处理为一个元素。 ReplaceRange方法通过适当的索引替换/移除/添加所需的元素，并对可能的事件进行批处理。

在 Xamarin.FormsUI 上进行了测试，结果非常好，可以频繁地对大型集合进行更新(每秒5-7次更新)。

注: 由于 WPF不习惯使用范围操作，当在 WPF UI 相关的工作中使用下面的 ObservableRangeCollection时，它会抛出一个 NotSupportedException，比如将它绑定到 ListBox等(如果没有绑定到 UI，你仍然可以使用 ObservableRangeCollection<T>)。
但是，您可以使用 WpfObservableRangeCollection<T>工作区。
真正的解决方案是创建一个知道如何处理范围操作的 CollectionView，但我仍然没有时间来实现这一点。

RAW 码 -打开为 RAW，然后执行 Ctrl + A全部选中，然后执行 Ctrl + C全部复制。

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.


using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;


namespace System.Collections.ObjectModel
{
/// <summary>
/// Implementation of a dynamic data collection based on generic Collection&lt;T&gt;,
/// implementing INotifyCollectionChanged to notify listeners
/// when items get added, removed or the whole list is refreshed.
/// </summary>
public class ObservableRangeCollection<T> : ObservableCollection<T>
{
//------------------------------------------------------
//
//  Private Fields
//
//------------------------------------------------------


#region Private Fields
[NonSerialized]
private DeferredEventsCollection _deferredEvents;
#endregion Private Fields




//------------------------------------------------------
//
//  Constructors
//
//------------------------------------------------------


#region Constructors
/// <summary>
/// Initializes a new instance of ObservableCollection that is empty and has default initial capacity.
/// </summary>
public ObservableRangeCollection() { }


/// <summary>
/// Initializes a new instance of the ObservableCollection class that contains
/// elements copied from the specified collection and has sufficient capacity
/// to accommodate the number of elements copied.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new list.</param>
/// <remarks>
/// The elements are copied onto the ObservableCollection in the
/// same order they are read by the enumerator of the collection.
/// </remarks>
/// <exception cref="ArgumentNullException"> collection is a null reference </exception>
public ObservableRangeCollection(IEnumerable<T> collection) : base(collection) { }


/// <summary>
/// Initializes a new instance of the ObservableCollection class
/// that contains elements copied from the specified list
/// </summary>
/// <param name="list">The list whose elements are copied to the new list.</param>
/// <remarks>
/// The elements are copied onto the ObservableCollection in the
/// same order they are read by the enumerator of the list.
/// </remarks>
/// <exception cref="ArgumentNullException"> list is a null reference </exception>
public ObservableRangeCollection(List<T> list) : base(list) { }


#endregion Constructors


//------------------------------------------------------
//
//  Public Methods
//
//------------------------------------------------------


#region Public Methods


/// <summary>
/// Adds the elements of the specified collection to the end of the <see cref="ObservableCollection{T}"/>.
/// </summary>
/// <param name="collection">
/// The collection whose elements should be added to the end of the <see cref="ObservableCollection{T}"/>.
/// The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type.
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
public void AddRange(IEnumerable<T> collection)
{
InsertRange(Count, collection);
}


/// <summary>
/// Inserts the elements of a collection into the <see cref="ObservableCollection{T}"/> at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which the new elements should be inserted.</param>
/// <param name="collection">The collection whose elements should be inserted into the List<T>.
/// The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type.</param>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is not in the collection range.</exception>
public void InsertRange(int index, IEnumerable<T> collection)
{
if (collection == null)
throw new ArgumentNullException(nameof(collection));
if (index < 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (index > Count)
throw new ArgumentOutOfRangeException(nameof(index));


if (collection is ICollection<T> countable)
{
if (countable.Count == 0)
{
return;
}
}
else if (!ContainsAny(collection))
{
return;
}


CheckReentrancy();


//expand the following couple of lines when adding more constructors.
var target = (List<T>)Items;
target.InsertRange(index, collection);


OnEssentialPropertiesChanged();


if (!(collection is IList list))
list = new List<T>(collection);


OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, list, index));
}




/// <summary>
/// Removes the first occurence of each item in the specified collection from the <see cref="ObservableCollection{T}"/>.
/// </summary>
/// <param name="collection">The items to remove.</param>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
public void RemoveRange(IEnumerable<T> collection)
{
if (collection == null)
throw new ArgumentNullException(nameof(collection));


if (Count == 0)
{
return;
}
else if (collection is ICollection<T> countable)
{
if (countable.Count == 0)
return;
else if (countable.Count == 1)
using (IEnumerator<T> enumerator = countable.GetEnumerator())
{
enumerator.MoveNext();
Remove(enumerator.Current);
return;
}
}
else if (!(ContainsAny(collection)))
{
return;
}


CheckReentrancy();


var clusters = new Dictionary<int, List<T>>();
var lastIndex = -1;
List<T> lastCluster = null;
foreach (T item in collection)
{
var index = IndexOf(item);
if (index < 0)
{
continue;
}


Items.RemoveAt(index);


if (lastIndex == index && lastCluster != null)
{
lastCluster.Add(item);
}
else
{
clusters[lastIndex = index] = lastCluster = new List<T> { item };
}
}


OnEssentialPropertiesChanged();


if (Count == 0)
OnCollectionReset();
else
foreach (KeyValuePair<int, List<T>> cluster in clusters)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, cluster.Value, cluster.Key));


}


/// <summary>
/// Iterates over the collection and removes all items that satisfy the specified match.
/// </summary>
/// <remarks>The complexity is O(n).</remarks>
/// <param name="match"></param>
/// <returns>Returns the number of elements that where </returns>
/// <exception cref="ArgumentNullException"><paramref name="match"/> is null.</exception>
public int RemoveAll(Predicate<T> match)
{
return RemoveAll(0, Count, match);
}


/// <summary>
/// Iterates over the specified range within the collection and removes all items that satisfy the specified match.
/// </summary>
/// <remarks>The complexity is O(n).</remarks>
/// <param name="index">The index of where to start performing the search.</param>
/// <param name="count">The number of items to iterate on.</param>
/// <param name="match"></param>
/// <returns>Returns the number of elements that where </returns>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is out of range.</exception>
/// <exception cref="ArgumentNullException"><paramref name="match"/> is null.</exception>
public int RemoveAll(int index, int count, Predicate<T> match)
{
if (index < 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (count < 0)
throw new ArgumentOutOfRangeException(nameof(count));
if (index + count > Count)
throw new ArgumentOutOfRangeException(nameof(index));
if (match == null)
throw new ArgumentNullException(nameof(match));


if (Count == 0)
return 0;


List<T> cluster = null;
var clusterIndex = -1;
var removedCount = 0;


using (BlockReentrancy())
using (DeferEvents())
{
for (var i = 0; i < count; i++, index++)
{
T item = Items[index];
if (match(item))
{
Items.RemoveAt(index);
removedCount++;


if (clusterIndex == index)
{
Debug.Assert(cluster != null);
cluster.Add(item);
}
else
{
cluster = new List<T> { item };
clusterIndex = index;
}


index--;
}
else if (clusterIndex > -1)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, cluster, clusterIndex));
clusterIndex = -1;
cluster = null;
}
}


if (clusterIndex > -1)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, cluster, clusterIndex));
}


if (removedCount > 0)
OnEssentialPropertiesChanged();


return removedCount;
}


/// <summary>
/// Removes a range of elements from the <see cref="ObservableCollection{T}"/>>.
/// </summary>
/// <param name="index">The zero-based starting index of the range of elements to remove.</param>
/// <param name="count">The number of elements to remove.</param>
/// <exception cref="ArgumentOutOfRangeException">The specified range is exceeding the collection.</exception>
public void RemoveRange(int index, int count)
{
if (index < 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (count < 0)
throw new ArgumentOutOfRangeException(nameof(count));
if (index + count > Count)
throw new ArgumentOutOfRangeException(nameof(index));


if (count == 0)
return;


if (count == 1)
{
RemoveItem(index);
return;
}


//Items will always be List<T>, see constructors
var items = (List<T>)Items;
List<T> removedItems = items.GetRange(index, count);


CheckReentrancy();


items.RemoveRange(index, count);


OnEssentialPropertiesChanged();


if (Count == 0)
OnCollectionReset();
else
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, index));
}


/// <summary>
/// Clears the current collection and replaces it with the specified collection,
/// using the default <see cref="EqualityComparer{T}"/>.
/// </summary>
/// <param name="collection">The items to fill the collection with, after clearing it.</param>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
public void ReplaceRange(IEnumerable<T> collection)
{
ReplaceRange(0, Count, collection, EqualityComparer<T>.Default);
}


/// <summary>
/// Clears the current collection and replaces it with the specified collection,
/// using the specified comparer to skip equal items.
/// </summary>
/// <param name="collection">The items to fill the collection with, after clearing it.</param>
/// <param name="comparer">An <see cref="IEqualityComparer{T}"/> to be used
/// to check whether an item in the same location already existed before,
/// which in case it would not be added to the collection, and no event will be raised for it.</param>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="comparer"/> is null.</exception>
public void ReplaceRange(IEnumerable<T> collection, IEqualityComparer<T> comparer)
{
ReplaceRange(0, Count, collection, comparer);
}


/// <summary>
/// Removes the specified range and inserts the specified collection,
/// ignoring equal items (using <see cref="EqualityComparer{T}.Default"/>).
/// </summary>
/// <param name="index">The index of where to start the replacement.</param>
/// <param name="count">The number of items to be replaced.</param>
/// <param name="collection">The collection to insert in that location.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is out of range.</exception>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
public void ReplaceRange(int index, int count, IEnumerable<T> collection)
{
ReplaceRange(index, count, collection, EqualityComparer<T>.Default);
}


/// <summary>
/// Removes the specified range and inserts the specified collection in its position, leaving equal items in equal positions intact.
/// </summary>
/// <param name="index">The index of where to start the replacement.</param>
/// <param name="count">The number of items to be replaced.</param>
/// <param name="collection">The collection to insert in that location.</param>
/// <param name="comparer">The comparer to use when checking for equal items.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is out of range.</exception>
/// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="comparer"/> is null.</exception>
public void ReplaceRange(int index, int count, IEnumerable<T> collection, IEqualityComparer<T> comparer)
{
if (index < 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (count < 0)
throw new ArgumentOutOfRangeException(nameof(count));
if (index + count > Count)
throw new ArgumentOutOfRangeException(nameof(index));


if (collection == null)
throw new ArgumentNullException(nameof(collection));
if (comparer == null)
throw new ArgumentNullException(nameof(comparer));


if (collection is ICollection<T> countable)
{
if (countable.Count == 0)
{
RemoveRange(index, count);
return;
}
}
else if (!ContainsAny(collection))
{
RemoveRange(index, count);
return;
}


if (index + count == 0)
{
InsertRange(0, collection);
return;
}


if (!(collection is IList<T> list))
list = new List<T>(collection);


using (BlockReentrancy())
using (DeferEvents())
{
var rangeCount = index + count;
var addedCount = list.Count;


var changesMade = false;
List<T>
newCluster = null,
oldCluster = null;




int i = index;
for (; i < rangeCount && i - index < addedCount; i++)
{
//parallel position
T old = this[i], @new = list[i - index];
if (comparer.Equals(old, @new))
{
OnRangeReplaced(i, newCluster, oldCluster);
continue;
}
else
{
Items[i] = @new;


if (newCluster == null)
{
Debug.Assert(oldCluster == null);
newCluster = new List<T> { @new };
oldCluster = new List<T> { old };
}
else
{
newCluster.Add(@new);
oldCluster.Add(old);
}


changesMade = true;
}
}


OnRangeReplaced(i, newCluster, oldCluster);


//exceeding position
if (count != addedCount)
{
var items = (List<T>)Items;
if (count > addedCount)
{
var removedCount = rangeCount - addedCount;
T[] removed = new T[removedCount];
items.CopyTo(i, removed, 0, removed.Length);
items.RemoveRange(i, removedCount);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed, i));
}
else
{
var k = i - index;
T[] added = new T[addedCount - k];
for (int j = k; j < addedCount; j++)
{
T @new = list[j];
added[j - k] = @new;
}
items.InsertRange(i, added);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, added, i));
}


OnEssentialPropertiesChanged();
}
else if (changesMade)
{
OnIndexerPropertyChanged();
}
}
}


#endregion Public Methods




//------------------------------------------------------
//
//  Protected Methods
//
//------------------------------------------------------


#region Protected Methods


/// <summary>
/// Called by base class Collection&lt;T&gt; when the list is being cleared;
/// raises a CollectionChanged event to any listeners.
/// </summary>
protected override void ClearItems()
{
if (Count == 0)
return;


CheckReentrancy();
base.ClearItems();
OnEssentialPropertiesChanged();
OnCollectionReset();
}


/// <summary>
/// Called by base class Collection&lt;T&gt; when an item is set in list;
/// raises a CollectionChanged event to any listeners.
/// </summary>
protected override void SetItem(int index, T item)
{
if (Equals(this[index], item))
return;


CheckReentrancy();
T originalItem = this[index];
base.SetItem(index, item);


OnIndexerPropertyChanged();
OnCollectionChanged(NotifyCollectionChangedAction.Replace, originalItem, item, index);
}


/// <summary>
/// Raise CollectionChanged event to any listeners.
/// Properties/methods modifying this ObservableCollection will raise
/// a collection changed event through this virtual method.
/// </summary>
/// <remarks>
/// When overriding this method, either call its base implementation
/// or call <see cref="BlockReentrancy"/> to guard against reentrant collection changes.
/// </remarks>
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
if (_deferredEvents != null)
{
_deferredEvents.Add(e);
return;
}
base.OnCollectionChanged(e);
}


protected virtual IDisposable DeferEvents() => new DeferredEventsCollection(this);


#endregion Protected Methods




//------------------------------------------------------
//
//  Private Methods
//
//------------------------------------------------------


#region Private Methods


/// <summary>
/// Helper function to determine if a collection contains any elements.
/// </summary>
/// <param name="collection">The collection to evaluate.</param>
/// <returns></returns>
private static bool ContainsAny(IEnumerable<T> collection)
{
using (IEnumerator<T> enumerator = collection.GetEnumerator())
return enumerator.MoveNext();
}


/// <summary>
/// Helper to raise Count property and the Indexer property.
/// </summary>
private void OnEssentialPropertiesChanged()
{
OnPropertyChanged(EventArgsCache.CountPropertyChanged);
OnIndexerPropertyChanged();
}


/// <summary>
/// /// Helper to raise a PropertyChanged event for the Indexer property
/// /// </summary>
private void OnIndexerPropertyChanged() =>
OnPropertyChanged(EventArgsCache.IndexerPropertyChanged);


/// <summary>
/// Helper to raise CollectionChanged event to any listeners
/// </summary>
private void OnCollectionChanged(NotifyCollectionChangedAction action, object oldItem, object newItem, int index) =>
OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index));


/// <summary>
/// Helper to raise CollectionChanged event with action == Reset to any listeners
/// </summary>
private void OnCollectionReset() =>
OnCollectionChanged(EventArgsCache.ResetCollectionChanged);


/// <summary>
/// Helper to raise event for clustered action and clear cluster.
/// </summary>
/// <param name="followingItemIndex">The index of the item following the replacement block.</param>
/// <param name="newCluster"></param>
/// <param name="oldCluster"></param>
//TODO should have really been a local method inside ReplaceRange(int index, int count, IEnumerable<T> collection, IEqualityComparer<T> comparer),
//move when supported language version updated.
private void OnRangeReplaced(int followingItemIndex, ICollection<T> newCluster, ICollection<T> oldCluster)
{
if (oldCluster == null || oldCluster.Count == 0)
{
Debug.Assert(newCluster == null || newCluster.Count == 0);
return;
}


OnCollectionChanged(
new NotifyCollectionChangedEventArgs(
NotifyCollectionChangedAction.Replace,
new List<T>(newCluster),
new List<T>(oldCluster),
followingItemIndex - oldCluster.Count));


oldCluster.Clear();
newCluster.Clear();
}


#endregion Private Methods


//------------------------------------------------------
//
//  Private Types
//
//------------------------------------------------------


#region Private Types
private sealed class DeferredEventsCollection : List<NotifyCollectionChangedEventArgs>, IDisposable
{
private readonly ObservableRangeCollection<T> _collection;
public DeferredEventsCollection(ObservableRangeCollection<T> collection)
{
Debug.Assert(collection != null);
Debug.Assert(collection._deferredEvents == null);
_collection = collection;
_collection._deferredEvents = this;
}


public void Dispose()
{
_collection._deferredEvents = null;
foreach (var args in this)
_collection.OnCollectionChanged(args);
}
}


#endregion Private Types


}


/// <remarks>
/// To be kept outside <see cref="ObservableCollection{T}"/>, since otherwise, a new instance will be created for each generic type used.
/// </remarks>
internal static class EventArgsCache
{
internal static readonly PropertyChangedEventArgs CountPropertyChanged = new PropertyChangedEventArgs("Count");
internal static readonly PropertyChangedEventArgs IndexerPropertyChanged = new PropertyChangedEventArgs("Item[]");
internal static readonly NotifyCollectionChangedEventArgs ResetCollectionChanged = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
}
}

小开

这是一个简单的可观察的集合，在 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);
}
}