반응형
ObservableCollection AddRange 메서드를 지원하지 않기 때문에 추가된 각 항목에 대해 알림을 받고, INNotifyCollectionChanging은 어떻게 됩니까?
범위를 추가하고 전체 벌크에 대해 업데이트를 받고 싶습니다.
작업이 완료되기 전에 작업을 취소할 수도 있습니다(즉, '변경된' 외에 수집이 변경됨).
관련 Q 어떤 것.여러 개체를 한 번에 추가하고 알림을 받기 위한 순 수집?
업데이트 및 최적화된 C# 7 버전을 참조하시기 바랍니다.저는 VB를 제거하고 싶지 않았습니다.NET 버전이라 다른 답변으로 올렸습니다.
업데이트된 버전으로 이동
지원되지 않는 것 같습니다. 저는 혼자 구현했습니다. FYI, 도움이 되기를 바랍니다.
버전을 하기 전에 할 수 . ("VB"와 함께 할 때 합니다.)DataGrid,ListView사용자에게 "확인하시겠습니까?" 확인 메시지를 표시할 수 있습니다.) 업데이트된 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
우선 에 대한 API 요청에 대한 투표와 의견을 부탁드립니다.NET repo.
여기 최적화된 버전이 있습니다.ObservableRangeCollection(James Montemagno의 작품을 최적화한 버전)
성능이 매우 빠르며 가능하면 기존 요소를 재사용하고 불필요한 이벤트를 방지하거나 가능하면 하나로 배치합니다. 그ReplaceRangemethod는 필요한 요소를 적절한 인덱스로 대체/수정/수정하고 가능한 이벤트를 배치합니다.
사마린에서 테스트했습니다.대용량 컬렉션에 대한 매우 빈번한 업데이트(초당 5-7개 업데이트)를 위해 우수한 결과를 제공하는 UI를 형성합니다.
참고: WPF는 범위 작업에 익숙하지 않기 때문에 다음과 같은 작업을 수행합니다.NotSupportedException를 할 때ObservableRangeCollection에 바인딩하는 등 UI 작업에서 부터.ListBox등등. (당신은 여전히 사용할 수 있습니다.ObservableRangeCollection<T>UI에 바인딩되지 않은 경우).
그러나 해결 방법을 사용할 수 있습니다.
▁a다▁be▁creating를 만드는 것입니다.CollectionView사정거리 작전을 다루는 방법을 알고 있지만, 아직도 이걸 실행할 시간이 없었습니다.
RAW 코드 - Raw로 연 다음 +를 A수행하여 모두를 선택하고 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<T>,
/// 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<T> 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<T> 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는 다음과 같이 구현하는 것이 더 좋다고 생각합니다.
public void AddRange(IEnumerable<T> collection)
{
foreach (var i in collection) Items.Add(i);
OnCollectionChanged(
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
목록 복사본을 저장합니다.또한 미세 최적화를 원하는 경우 최대 N개의 항목에 대해 추가하고 N개 이상의 항목이 추가된 경우 재설정할 수 있습니다.
사용자 정의 컬렉션에 UI를 바인딩할 때 주의해야 합니다. Default CollectionView 클래스는 항목에 대한 단일 알림만 지원합니다.
다음에 대한 필요성 증명OnPropertyChanged("Count")그리고.OnPropertyChanged("Item[]") 따라 ObservableCollection당신이 귀찮게 하지 않으면 어떤 결과가 나올지 모릅니다!
다음은 정상적으로 관찰 가능한 컬렉션에서 각 추가에 대해 두 개의 속성 변경 이벤트가 있음을 보여주는 테스트 방법입니다.는 원포입니다."Count"는 고하나는리그▁for."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, 컬렉션의 표준을 바꾸고 추가 범위로 변경하면 속성 변경이 0이 됩니다.컬렉션 변경은 정상적으로 작동하지만 관찰 가능한 컬렉션과 정확히 일치하지는 않습니다.Shimmy 컬렉션에 대한 테스트는 다음과 같습니다.
[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 :(
}
참고로 관찰 가능한 컬렉션의 InsertItem(추가라고도 함)의 코드는 다음과 같습니다.
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);
}
관찰 가능한 컬렉션에 대해 수행해야 할 작업이 여러 개 있을 수 있으므로 먼저 지우기, 범위 추가, 콤보 상자에 대해 "모든" 항목 삽입 등의 작업을 수행하면 다음과 같은 해결책을 얻을 수 있습니다.
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# 요약 하위 항목입니다.
더 읽기: http://blogs.msdn.com/b/nathannesbit/archive/2009/04/20/addrange-and-observablecollection.aspx
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
}
}
예, 사용자 지정 관찰 가능 컬렉션을 추가하는 것이 좋습니다.현재 UI에서 사용되는지 여부에 관계없이 적절한 이벤트를 발생시키는 것을 잊지 마십시오. ;) 항목 집합(사용자 범위)이 추가된 NotifyCollectionChangedEventArgs뿐만 아니라 "Item[]" 속성(WPF 측 및 바인딩 컨트롤에 필요)에 대한 속성 변경 알림을 발생시켜야 합니다.정렬 지원 및 기타 작업을 수행했으며 프레젠테이션 및 코드 이면 계층 모두에서 문제가 없었습니다.
다음은 변경된 수집 및 UI 문제에 대한 추가 도움말입니다.
ObservableRangeCollection은 다음과 같은 테스트를 통과해야 합니다.
[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 을 참조하십시오.
이 게시물 https://peteohanlon.wordpress.com/2008/10/22/bulk-loading-in-observablecollection/ 을 기반으로 AddRange 메서드의 마지막에 통보하는 단순한 관찰 가능한 컬렉션입니다.
또한 이 게시물 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);
}
}
다음은 더 많은 기능을 제공하기 위해 허용된 답변을 수정한 것입니다.
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기본 메소드에서만 생성할 수 있는 것으로 보이기 때문에 기본 메소드에서CollectionChangedEventArgs사용Reset액션.만약 당신이 키우려고 노력한다면,OnCollectionChanged사용.Reset단일 항목 변경 시 항목 제어가 깜박이는 것으로 나타나므로 이를 방지해야 합니다.
이 코드를 사용하여 관찰 가능한 컬렉션을 확장할 수도 있습니다.
public static class ObservableCollectionExtend
{
public static void AddRange<TSource>(this ObservableCollection<TSource> source, IEnumerable<TSource> items)
{
foreach (var item in items)
{
source.Add(item);
}
}
}
그러면 기존 코드에서 클래스를 변경할 필요가 없습니다.
언급URL : https://stackoverflow.com/questions/670577/observablecollection-doesnt-support-addrange-method-so-i-get-notified-for-each
반응형
'source' 카테고리의 다른 글
| 키보드에 브레이크 키가 없을 때 VBA 브레이크 실행을 향상시킵니다. (0) | 2023.05.07 |
|---|---|
| 성능이 더 좋은 방법은 무엇입니까: .숫자() 대 숫자() > 0? (0) | 2023.05.07 |
| WPF 텍스트 블록을 선택할 수 있는 방법이 있습니까? (0) | 2023.05.07 |
| Postgresql - 데이터베이스 및 복원을 다른 소유자에게 백업하시겠습니까? (0) | 2023.05.07 |
| 외부 스크립트가 로드되었는지 확인 (0) | 2023.05.07 |