blocks|key|1842172|text|您必须小心地将UI绑定到您的自定义集合--默认的CollectionView类只支持单个项通知。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842173|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You will have to be careful binding the UI to your custom collection -- the Default CollectionView class only supports single notification of items.

blocks|key|2056393|text|是的，添加您自己的自定义可观察集合将是足够公平的。别忘了引发适当的事件，不管它目前是否被UI使用;)你将不得不引发"Item[]“属性的属性更改通知(+WPF侧边和绑定的控件需要)以及添加了一组项的NotifyCollectionChangedEventArgs+(你的范围)。我做过这样的事情(以及排序支持和其他一些东西)，在表示层和层后代码方面都没有问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2056394|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, adding your own Custom Observable Collection would be fair enough. Don't forget to raise appropriate events regardless whether it is used by UI for the moment or not ;) You will have to raise property change notification for "Item[]" property (required by WPF side and bound controls) as well as NotifyCollectionChangedEventArgs with a set of items added (your range). 
I've did such things (as well as sorting support and some other stuff) and had no problems with both Presentation and Code Behind layers.

blocks|key|1842345|text|我认为AddRange更好的实现方式如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842346|public+void+AddRange(IEnumerable<T>+collection)
{
++++foreach+(var+i+in+collection)+Items.Add(i);
++++OnCollectionChanged(
++++++++new+NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}|code-block|syntax|javascript|1842347|它为您保存了一个列表副本。此外，如果你想进行微优化，你可以添加多达N个项目，如果添加的项目超过N个，则进行重置。|1842348|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think AddRange is better implemented like so: 

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

It saves you a list copy. Also if you want to micro-optimise you could do adds for up to N items and if more than N items where added do a reset.

blocks|key|2056496|text|Here是针对集合更改和UI问题的一些额外帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2056497|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/KB/dotnet/MTObservableCollection.aspx?msg=3412002^0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://www.codeproject.com/KB/dotnet/MTObservableCollection.aspx?msg=3412002" rel="nofollow">Here</a> is some additional help for collection changed and UI issues:

blocks|key|1842453|text|需要OnPropertyChanged("Count")和OnPropertyChanged("Item[]")调用才能按照ObservableCollection运行的证明。请注意，如果您不费心，我不知道后果是什么！|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1842454|下面是一个测试方法，它显示了一个正常的可观察集合中的每个add都有两个PropertyChange事件。一个用于"Count"，另一个用于"Item[]"。|1842455|[TestMethod]
public+void+TestAddSinglesInOldObsevableCollection()
{
++int+colChangedEvents+=+0;
++int+propChangedEvents+=+0;
++var+collection+=+new+ObservableCollection<object>();
++collection.CollectionChanged+%2B=+(sender,+e)+=>+{+colChangedEvents%2B%2B;+};
++(collection+as+INotifyPropertyChanged).PropertyChanged+%2B=+(sender,+e)+=>+{+propChangedEvents%2B%2B;+};
++collection.Add(new+object());
++collection.Add(new+object());
++collection.Add(new+object());
++Assert.AreEqual(3,+colChangedEvents);
++Assert.AreEqual(6,+propChangedEvents);
}|code-block|syntax|javascript|1842456|@Shimmy，交换您的集合的标准，并更改为添加范围，您将获得零PropertyChanges。请注意，集合更改确实工作得很好，但并不完全像ObservableCollection那样工作。因此，测试shimmy集合如下所示：|1842457|[TestMethod]
public+void+TestShimmyAddRange()
{
++int+colChangedEvents+=+0;
++int+propChangedEvents+=+0;
++var+collection+=+new+ShimmyObservableCollection<object>();
++collection.CollectionChanged+%2B=+(sender,+e)+=>+{+colChangedEvents%2B%2B;+};
++(collection+as+INotifyPropertyChanged).PropertyChanged+%2B=+(sender,+e)+=>+{+propChangedEvents%2B%2B;+};
++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+:(
}|1842458|仅供参考，这里是来自ObservableCollection的InsertItem+(也被Add调用)的代码：|1842459|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);
}|1842460|entityMap^0|2|Q|T|R|1Q|K|0|1K|7|1X|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1B|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|V|$]]

Proof of need for <code>OnPropertyChanged("Count")</code> and <code>OnPropertyChanged("Item[]")</code> calls in order to behave as per <code>ObservableCollection</code>. Note that I don't know what the consequences are if you don't bother!

Here is a test method that shows that there are two PropertyChange events for each add in a normal observable collection. One for <code>"Count"</code> and one for <code>"Item[]"</code>.

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

@Shimmy , swap the standard for your collection and change to an add range and you will get zero PropertyChanges. Note that collection change does work fine, but not doing exactly what ObservableCollection does. So Test for shimmy collection looks like this:

<pre><code>[TestMethod]
public void TestShimmyAddRange()
{
 int colChangedEvents = 0;
 int propChangedEvents = 0;
 var collection = new ShimmyObservableCollection&lt;object&gt;();
 collection.CollectionChanged += (sender, e) =&gt; { colChangedEvents++; };
 (collection as INotifyPropertyChanged).PropertyChanged += (sender, e) =&gt; { 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 :(
}
</code></pre>

FYI here is code from InsertItem (also called by Add) from ObservableCollection:

<pre><code>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);
}
</code></pre>

blocks|key|1842516|text|您还可以使用以下代码来扩展ObservableCollection：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842517|public+static+class+ObservableCollectionExtend
{
++++public+static+void+AddRange<TSource>(this+ObservableCollection<TSource>+source,+IEnumerable<TSource>+items)
++++{
++++++++foreach+(var+item+in+items)
++++++++{
++++++++++++source.Add(item);
++++++++}
++++}
}|code-block|syntax|javascript|1842518|这样你就不需要改变现有代码中的类了。|1842519|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can also use this code to extend ObservableCollection:

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

Then you don't need to change class in existing code.

blocks|key|1842567|text|由于在ObservableCollection上可能有许多操作要做，例如，首先清除，然后清除AddRange，然后为ComboBox插入"All“项，我最终得到了以下解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842568|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));
++++}
}|code-block|syntax|javascript|1842569|并举例说明如何使用它：|1842570|MyDogs.Execute(items+=>
{
++++items.Clear();
++++items.AddRange(Context.Dogs);
++++items.Insert(0,+new+Dog+{+Id+=+0,+Name+=+"All+Dogs"+});
});|1842571|重置通知只会在Execute处理完底层列表之后调用一次。|1842572|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

As there might be a number of operations to do on an ObservableCollection for example Clear first then AddRange and then insert "All" item for a ComboBox I ended up with folowing solution:

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

 return source;
 }
}

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

And example how to use it:

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

The Reset notification will be called only once after Execute is finished processing the underlying list.

blocks|key|1842587|text|C#汇总的子体。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842588|更多信息：http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx|offset|length|1842589|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
++++}
}|code-block|syntax|javascript|1842590|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx^0|0|5|2M|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

The C# summarized descendant.

More reading: <a href="http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx" rel="nofollow">http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx</a>

<pre><code>public sealed class ObservableCollectionEx&lt;T&gt; : ObservableCollection&lt;T&gt;
{
 #region Ctor

 public ObservableCollectionEx()
 {
 }

 public ObservableCollectionEx(List&lt;T&gt; list) : base(list)
 {
 }

 public ObservableCollectionEx(IEnumerable&lt;T&gt; collection) : base(collection)
 {
 }

 #endregion

 /// &lt;summary&gt; 
 /// Adds the elements of the specified collection to the end of the ObservableCollection(Of T). 
 /// &lt;/summary&gt; 
 public void AddRange(
 IEnumerable&lt;T&gt; 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&lt;T&gt; ? (List&lt;T&gt;) itemsToAdd : new List&lt;T&gt;(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
 {
 /// &lt;summary&gt;
 /// Notifies that only a portion of data was changed and supplies the changed items (not supported by some elements,
 /// like CollectionView class).
 /// &lt;/summary&gt;
 Add,

 /// &lt;summary&gt;
 /// 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).
 /// &lt;/summary&gt;
 Reset
 }
}
</code></pre>

blocks|key|1842666|text|ObservableRangeCollection应该通过像这样的测试|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1842667|[Test]
public+void+TestAddRangeWhileBoundToListCollectionView()
{
++++int+collectionChangedEventsCounter+=+0;
++++int+propertyChangedEventsCounter+=+0;
++++var+collection+=+new+ObservableRangeCollection<object>();

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

++++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);
}|code-block|syntax|javascript|1842668|否则我们会得到|1842669|System.NotSupportedException+:+Range+actions+are+not+supported.|1842670|在与控件一起使用时。|1842671|我没有看到一个理想的解决方案，但是NotifyCollectionChangedAction.Reset代替了Add/Remove部分解决了这个问题。请参阅net_prog提到的http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx|offset|length|1842672|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx^0|0|0|0|0|0|2H|2M|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

ObservableRangeCollection should pass a test like

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

 collection.CollectionChanged += (sender, e) =&gt; { collectionChangedEventsCounter++; };
 (collection as INotifyPropertyChanged).PropertyChanged += (sender, e) =&gt; { 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);
}
</code></pre>

otherwise we get 

<pre><code>System.NotSupportedException : Range actions are not supported.
</code></pre>

while using with a control.

I do not see an ideal solution, but NotifyCollectionChangedAction.Reset instead of Add/Remove partially solve the problem. See <a href="http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx" rel="nofollow">http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx</a> as was mentioned by net_prog

blocks|key|2057071|text|以下是对已接受答案的修改，以提供更多功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2057072|RangeCollection.cs：|2057073|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%2B%2B;
++++++++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%2B%2B;
++++++++}
++++}

++++///+<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
}|code-block|syntax|javascript|2057074|事件类：|2057075|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;
++++}
}|2057076|注意:我没有在基本方法中手动引发OnCollectionChanged，因为似乎只有使用Reset操作才能创建CollectionChangedEventArgs。如果您尝试使用Reset为单个项更改引发OnCollectionChanged，则items控件将显示为闪烁，这是您希望避免的情况。|offset|length|style|CODE|2057077|entityMap^0|0|0|0|0|0|G|J|18|5|1J|Q|2H|5|2U|J|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]|$O|14|P|15|Q|R]|$O|16|P|17|Q|R]|$O|18|P|19|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$]]

Here's a modification of the accepted answer to provide more functionality.

RangeCollection.cs:

<pre><code>public class RangeCollection&lt;T&gt; : ObservableCollection&lt;T&gt;
{
 #region Members

 /// &lt;summary&gt;
 /// Occurs when a single item is added.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemAddedEventArgs&lt;T&gt;&gt; ItemAdded;

 /// &lt;summary&gt;
 /// Occurs when a single item is inserted.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemInsertedEventArgs&lt;T&gt;&gt; ItemInserted;

 /// &lt;summary&gt;
 /// Occurs when a single item is removed.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemRemovedEventArgs&lt;T&gt;&gt; ItemRemoved;

 /// &lt;summary&gt;
 /// Occurs when a single item is replaced.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemReplacedEventArgs&lt;T&gt;&gt; ItemReplaced;

 /// &lt;summary&gt;
 /// Occurs when items are added to this.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemsAddedEventArgs&lt;T&gt;&gt; ItemsAdded;

 /// &lt;summary&gt;
 /// Occurs when items are removed from this.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemsRemovedEventArgs&lt;T&gt;&gt; ItemsRemoved;

 /// &lt;summary&gt;
 /// Occurs when items are replaced within this.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemsReplacedEventArgs&lt;T&gt;&gt; ItemsReplaced;

 /// &lt;summary&gt;
 /// Occurs when entire collection is cleared.
 /// &lt;/summary&gt;
 public event EventHandler&lt;ItemsClearedEventArgs&lt;T&gt;&gt; ItemsCleared;

 /// &lt;summary&gt;
 /// Occurs when entire collection is replaced.
 /// &lt;/summary&gt;
 public event EventHandler&lt;CollectionReplacedEventArgs&lt;T&gt;&gt; CollectionReplaced;

 #endregion

 #region Helper Methods

 /// &lt;summary&gt;
 /// Throws exception if any of the specified objects are null.
 /// &lt;/summary&gt;
 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&lt;T&gt; Items)
 {
 if (Items == null) throw new ArgumentNullException("Items cannot be null.");
 }

 private void Check(IEnumerable&lt;IEnumerable&lt;T&gt;&gt; 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

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

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

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

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

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

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

 private void Replace(T Old, T New, bool BreakFirst)
 {
 List&lt;T&gt; Cloned = new List&lt;T&gt;(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++;
 }
 }

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

 #endregion

 #region New Methods

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

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

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

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

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

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

 #endregion

 #region Event Methods

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

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

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

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

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

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

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

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

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

 #endregion

 #region RangeCollection

 /// &lt;summary&gt; 
 /// Initializes a new instance. 
 /// &lt;/summary&gt; 
 public RangeCollection() : base() { }

 /// &lt;summary&gt; 
 /// Initializes a new instance from specified enumerable. 
 /// &lt;/summary&gt; 
 public RangeCollection(IEnumerable&lt;T&gt; Collection) : base(Collection) { }

 /// &lt;summary&gt; 
 /// Initializes a new instance from specified list.
 /// &lt;/summary&gt; 
 public RangeCollection(List&lt;T&gt; List) : base(List) { }

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

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

 #endregion
}
</code></pre>

Events Classes:

<pre><code>public class CollectionReplacedEventArgs&lt;T&gt; : ReplacedEventArgs&lt;T&gt;
{
 public CollectionReplacedEventArgs(IEnumerable&lt;T&gt; Old, IEnumerable&lt;T&gt; New) : base(Old, New) { }
}

public class ItemAddedEventArgs&lt;T&gt; : EventArgs
{
 public T NewItem;
 public ItemAddedEventArgs(T t)
 {
 this.NewItem = t;
 }
}

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

public class ItemRemovedEventArgs&lt;T&gt; : EventArgs
{
 public T OldItem;
 public ItemRemovedEventArgs(T t)
 {
 this.OldItem = t;
 }
}

public class ItemReplacedEventArgs&lt;T&gt; : EventArgs
{
 public T OldItem;
 public T NewItem;
 public ItemReplacedEventArgs(T Old, T New)
 {
 this.OldItem = Old;
 this.NewItem = New;
 }
}

public class ItemsAddedEventArgs&lt;T&gt; : EventArgs
{
 public IEnumerable&lt;T&gt; NewItems;
 public ItemsAddedEventArgs(IEnumerable&lt;T&gt; t)
 {
 this.NewItems = t;
 }
}

public class ItemsClearedEventArgs&lt;T&gt; : RemovedEventArgs&lt;T&gt;
{
 public ItemsClearedEventArgs(IEnumerable&lt;T&gt; Old) : base(Old) { }
}

public class ItemsRemovedEventArgs&lt;T&gt; : RemovedEventArgs&lt;T&gt;
{
 public ItemsRemovedEventArgs(IEnumerable&lt;T&gt; Old) : base(Old) { }
}

public class ItemsReplacedEventArgs&lt;T&gt; : ReplacedEventArgs&lt;T&gt;
{
 public ItemsReplacedEventArgs(IEnumerable&lt;T&gt; Old, IEnumerable&lt;T&gt; New) : base(Old, New) { }
}

public class RemovedEventArgs&lt;T&gt; : EventArgs
{
 public IEnumerable&lt;T&gt; OldItems;
 public RemovedEventArgs(IEnumerable&lt;T&gt; Old)
 {
 this.OldItems = Old;
 }
}

public class ReplacedEventArgs&lt;T&gt; : EventArgs
{
 public IEnumerable&lt;T&gt; OldItems;
 public IEnumerable&lt;T&gt; NewItems;
 public ReplacedEventArgs(IEnumerable&lt;T&gt; Old, IEnumerable&lt;T&gt; New)
 {
 this.OldItems = Old;
 this.NewItems = New;
 }
}
</code></pre>

Note: I did not manually raise <code>OnCollectionChanged</code> in the base methods because it appears only to be possible to create a <code>CollectionChangedEventArgs</code> using the <code>Reset</code> action. If you try to raise <code>OnCollectionChanged</code> using <code>Reset</code> for a single item change, your items control will appear to flicker, which is something you want to avoid.

blocks|key|1843003|text|这是一个简单的可观察集合，基于这篇文章的https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/，它在AddRange方法的末尾进行通知|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1843004|它也是异步的，可以跨线程进行修改，基于这篇文章的https://thomaslevesque.com/2009/04/17/wpf-binding-to-an-asynchronous-collection/|1843005|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);
++++}
}|code-block|syntax|javascript|1843006|entityMap|0|LINK|mutability|MUTABLE|url|https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/|1|https://thomaslevesque.com/2009/04/17/wpf-binding-to-an-asynchronous-collection/^0|K|2A|0|0|O|28|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

this a simple observablecollection that notifies at the end of AddRange method, based on this post
<a href="https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/" rel="nofollow noreferrer">https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/</a>
it is also asynchronous and modifiable across threads, based on this post <a href="https://thomaslevesque.com/2009/04/17/wpf-binding-to-an-asynchronous-collection/" rel="nofollow noreferrer">https://thomaslevesque.com/2009/04/17/wpf-binding-to-an-asynchronous-collection/</a>
<pre><code>public class ConcurrentObservableCollection&lt;T&gt; : ObservableCollection&lt;T&gt;
{
 private SynchronizationContext _synchronizationContext = SynchronizationContext.Current;

 private bool _suppressNotification = false;

 public ConcurrentObservableCollection()
 : base()
 {
 }
 public ConcurrentObservableCollection(IEnumerable&lt;T&gt; list)
 : base(list)
 {
 }

 public void AddRange(IEnumerable&lt;T&gt; 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&lt;T&gt; 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);
 }
}
</code></pre>

I want to be able to add a range and get updated for the entire bulk.

I also want to be able to cancel the action before it's done (i.e. collection changing besides the 'changed').

<hr>

Related Q
<a href="https://stackoverflow.com/questions/57020/which-net-collection-for-adding-multiple-objects-at-once-and-getting-notified">Which .Net collection for adding multiple objects at once and getting notified?</a>

ObservableCollection Doesn't support AddRange method, so I get notified for each item added, besides what about INotifyCollectionChanging?

我希望能够添加一个范围，并获得整个批量更新。我还希望能够在操作完成之前取消该操作(即，除了“已更改”之外，集合还会发生变化)。相关Q 

问ObservableCollection不支持AddRange方法，所以添加的每一项都会通知我，除了INotifyCollectionChanging呢？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ObservableCollection不支持AddRange方法，所以添加的每一项都会通知我，除了INotifyCollectionChanging呢？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ObservableCollection不支持AddRange方法，所以添加的每一项都会通知我，除了INotifyCollectionChanging呢？
EN