97

私は本当に私を油断させている何かをここに持っています。

アイテムで満たされた T の ObservableCollection があります。CollectionChanged イベントにアタッチされたイベント ハンドラーもあります。

コレクションをクリアすると、e.Action が NotifyCollectionChangedAction.Reset に設定された CollectionChanged イベントが発生します。わかりました、それは正常です。しかし奇妙なのは、e.OldItems にも e.NewItems にも何も入っていないことです。コレクションから削除されたすべてのアイテムで e.OldItems が満たされることを期待します。

他の誰かがこれを見たことがありますか?もしそうなら、彼らはどのようにそれを回避しましたか?

背景: CollectionChanged イベントを使用して別のイベントにアタッチおよびデタッチしているため、e.OldItems でアイテムを取得しないと、そのイベントからデタッチできません。


明確化: 私は、ドキュメントがこのように動作しなければならないことを完全に述べていないことを知っています. しかし、他のすべてのアクションについては、それが何をしたかを私に通知しています。だから、私の仮定は、それが私に言うだろうということです...クリア/リセットの場合も同様です。


以下は、自分で再現したい場合のサンプルコードです。まずxamlから:

<Window
    x:Class="ObservableCollection.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1"
    Height="300"
    Width="300"
>
    <StackPanel>
        <Button x:Name="addButton" Content="Add" Width="100" Height="25" Margin="10" Click="addButton_Click"/>
        <Button x:Name="moveButton" Content="Move" Width="100" Height="25" Margin="10" Click="moveButton_Click"/>
        <Button x:Name="removeButton" Content="Remove" Width="100" Height="25" Margin="10" Click="removeButton_Click"/>
        <Button x:Name="replaceButton" Content="Replace" Width="100" Height="25" Margin="10" Click="replaceButton_Click"/>
        <Button x:Name="resetButton" Content="Reset" Width="100" Height="25" Margin="10" Click="resetButton_Click"/>
    </StackPanel>
</Window>

次に、コードビハインド:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;

namespace ObservableCollection
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            _integerObservableCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(_integerObservableCollection_CollectionChanged);
        }

        private void _integerObservableCollection_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Move:
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Replace:
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
                    break;
                default:
                    break;
            }
        }

        private void addButton_Click(object sender, RoutedEventArgs e)
        {
            _integerObservableCollection.Add(25);
        }

        private void moveButton_Click(object sender, RoutedEventArgs e)
        {
            _integerObservableCollection.Move(0, 19);
        }

        private void removeButton_Click(object sender, RoutedEventArgs e)
        {
            _integerObservableCollection.RemoveAt(0);
        }

        private void replaceButton_Click(object sender, RoutedEventArgs e)
        {
            _integerObservableCollection[0] = 50;
        }

        private void resetButton_Click(object sender, RoutedEventArgs e)
        {
            _integerObservableCollection.Clear();
        }

        private ObservableCollection<int> _integerObservableCollection = new ObservableCollection<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
    }
}
4

20 に答える 20

47

リセットはリストがクリアされたことを意味しないため、古いアイテムが含まれているとは主張しません。

これは、何か劇的なことが起こったことを意味し、追加/削除を実行するためのコストは、リストを最初から再スキャンするためのコストを超える可能性が高いため、そうする必要があります。

MSDN は、コレクション全体がリセットの候補として再ソートされる例を提案しています。

繰り返します。リセットはクリアを意味するのではなく、リストに関するあなたの仮定が無効になったことを意味します。まったく新しい list であるかのように扱います。Clear はたまたまこの例の 1 つですが、他にもある可能性があります。

いくつかの例:このようなリストに多くのアイテムが含まれており、画面に表示する
ために WPF にデータバインドされています。 リストをクリアしてイベントを発生させると、パフォーマンスはほとんど瞬時に向上しますが、代わりに多数の個々のイベントを発生させると、WPF がアイテムを 1 つずつ削除するため、パフォーマンスが大幅に低下します。また、独自のコードで、何千もの個別の操作を発行するのではなく、リストが再ソートされたことを示すために使用しました。Clear と同様に、多数の個々のイベントを発生させると、パフォーマンスが大幅に低下します。ListView
.Reset.Remove.ResetMove

于 2010-06-03T04:37:35.387 に答える
24

ここでも同じ問題がありました。CollectionChanged のリセット アクションには、OldItems は含まれません。回避策がありました。代わりに、次の拡張メソッドを使用しました。

public static void RemoveAll(this IList list)
{
   while (list.Count > 0)
   {
      list.RemoveAt(list.Count - 1);
   }
}

最終的に Clear() 関数をサポートせず、リセット アクションの CollectionChanged イベントで NotSupportedException をスローしました。RemoveAll は、適切な OldItems を使用して、CollectionChanged イベントで削除アクションをトリガーします。

于 2008-10-22T12:46:45.980 に答える
14

わかりました、これは非常に古い質問ですが、問題に対する良い解決策を思いついたので、共有したいと思いました. このソリューションは、ここでの多くの優れた回答からインスピレーションを得ていますが、次の利点があります。

  • ObservableCollection から新しいクラスを作成してメソッドをオーバーライドする必要はありません
  • NotifyCollectionChanged の動作を改ざんしません (リセットをいじることはありません)
  • 反射を利用しない

コードは次のとおりです。

 public static void Clear<T>(this ObservableCollection<T> collection, Action<ObservableCollection<T>> unhookAction)
 {
     unhookAction.Invoke(collection);
     collection.Clear();
 }

この拡張メソッドはAction、コレクションがクリアされる前に呼び出される を受け取るだけです。

于 2017-03-10T08:48:44.737 に答える
13

もう 1 つのオプションは、Reset イベントを、次のように OldItems プロパティにすべてのクリアされたアイテムを持つ単一の Remove イベントに置き換えることです。

public class ObservableCollectionNoReset<T> : ObservableCollection<T>
{
    protected override void ClearItems()
    {
        List<T> removed = new List<T>(this);
        base.ClearItems();
        base.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed));
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (e.Action != NotifyCollectionChangedAction.Reset)
            base.OnCollectionChanged(e);
    }
    // Constructors omitted
    ...
}

利点:

  1. 追加のイベントにサブスクライブする必要はありません (受け入れられた回答で必要な場合)

  2. 削除されたオブジェクトごとにイベントを生成しません (他のいくつかの提案されたソリューションでは、複数の Removed イベントが発生します)。

  3. サブスクライバーは、必要に応じてイベント ハンドラーを追加/削除するために、任意のイベントで NewItems と OldItems を確認するだけで済みます。

短所:

  1. リセットイベントなし

  2. リストのコピーを作成する小さな (?) オーバーヘッド。

  3. ???

編集 2012-02-23

残念ながら、WPF リスト ベースのコントロールにバインドされている場合、複数の要素を持つ ObservableCollectionNoReset コレクションをクリアすると、"Range actions not supported" という例外が発生します。この制限のあるコントロールで使用するために、ObservableCollectionNoReset クラスを次のように変更しました。

public class ObservableCollectionNoReset<T> : ObservableCollection<T>
{
    // Some CollectionChanged listeners don't support range actions.
    public Boolean RangeActionsSupported { get; set; }

    protected override void ClearItems()
    {
        if (RangeActionsSupported)
        {
            List<T> removed = new List<T>(this);
            base.ClearItems();
            base.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed));
        }
        else
        {
            while (Count > 0 )
                base.RemoveAt(Count - 1);
        }                
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (e.Action != NotifyCollectionChangedAction.Reset)
            base.OnCollectionChanged(e);
    }

    public ObservableCollectionNoReset(Boolean rangeActionsSupported = false) 
    {
        RangeActionsSupported = rangeActionsSupported;
    }

    // Additional constructors omitted.
 }

コレクション内のオブジェクトごとに 1 つの削除通知が生成されるため、RangeActionsSupported が false (デフォルト) の場合、これは効率的ではありません。

于 2012-01-21T03:49:57.357 に答える
9

私は、ユーザーが一度に多くの項目を追加または削除する効率を利用して、1 つのイベントのみを発生させ、Action.Reset イベント引数を取得する UIElements のニーズを満たすことができるソリューションを見つけました。追加および削除された要素のリストのように。

この解決策には、CollectionChanged イベントのオーバーライドが含まれます。このイベントを発生させると、登録された各ハンドラーのターゲットを実際に見て、それらのタイプを判別できます。NotifyCollectionChangedAction.Reset複数のアイテムが変更されたときに引数を必要とするのは ICollectionView クラスだけなので、それらを選択して、削除または追加されたアイテムの完全なリストを含む適切なイベント引数を他のすべての人に与えることができます。以下、実装です。

public class BaseObservableCollection<T> : ObservableCollection<T>
{
    //Flag used to prevent OnCollectionChanged from firing during a bulk operation like Add(IEnumerable<T>) and Clear()
    private bool _SuppressCollectionChanged = false;

    /// Overridden so that we may manually call registered handlers and differentiate between those that do and don't require Action.Reset args.
    public override event NotifyCollectionChangedEventHandler CollectionChanged;

    public BaseObservableCollection() : base(){}
    public BaseObservableCollection(IEnumerable<T> data) : base(data){}

    #region Event Handlers
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if( !_SuppressCollectionChanged )
        {
            base.OnCollectionChanged(e);
            if( CollectionChanged != null )
                CollectionChanged.Invoke(this, e);
        }
    }

    //CollectionViews raise an error when they are passed a NotifyCollectionChangedEventArgs that indicates more than
    //one element has been added or removed. They prefer to receive a "Action=Reset" notification, but this is not suitable
    //for applications in code, so we actually check the type we're notifying on and pass a customized event args.
    protected virtual void OnCollectionChangedMultiItem(NotifyCollectionChangedEventArgs e)
    {
        NotifyCollectionChangedEventHandler handlers = this.CollectionChanged;
        if( handlers != null )
            foreach( NotifyCollectionChangedEventHandler handler in handlers.GetInvocationList() )
                handler(this, !(handler.Target is ICollectionView) ? e : new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
    #endregion

    #region Extended Collection Methods
    protected override void ClearItems()
    {
        if( this.Count == 0 ) return;

        List<T> removed = new List<T>(this);
        _SuppressCollectionChanged = true;
        base.ClearItems();
        _SuppressCollectionChanged = false;
        OnCollectionChangedMultiItem(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed));
    }

    public void Add(IEnumerable<T> toAdd)
    {
        if( this == toAdd )
            throw new Exception("Invalid operation. This would result in iterating over a collection as it is being modified.");

        _SuppressCollectionChanged = true;
        foreach( T item in toAdd )
            Add(item);
        _SuppressCollectionChanged = false;
        OnCollectionChangedMultiItem(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<T>(toAdd)));
    }

    public void Remove(IEnumerable<T> toRemove)
    {
        if( this == toRemove )
            throw new Exception("Invalid operation. This would result in iterating over a collection as it is being modified.");

        _SuppressCollectionChanged = true;
        foreach( T item in toRemove )
            Remove(item);
        _SuppressCollectionChanged = false;
        OnCollectionChangedMultiItem(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, new List<T>(toRemove)));
    }
    #endregion
}
于 2012-02-23T15:57:02.020 に答える
8

わかりました、それでも ObservableCollection が希望どおりに動作することを望んでいます...以下のコードは、私が最終的に行ったことです。基本的に、TrulyObservableCollection という T の新しいコレクションを作成し、ClearItems メソッドをオーバーライドして Clearing イベントを発生させました。

この TrulyObservableCollection を使用するコードでは、この Clearing イベントを使用して、その時点でまだコレクション内にある項目をループ処理し、切り離したいイベントで切り離しを行います。

このアプローチが他の誰かにも役立つことを願っています。

public class TrulyObservableCollection<T> : ObservableCollection<T>
{
    public event EventHandler<EventArgs> Clearing;
    protected virtual void OnClearing(EventArgs e)
    {
        if (Clearing != null)
            Clearing(this, e);
    }

    protected override void ClearItems()
    {
        OnClearing(EventArgs.Empty);
        base.ClearItems();
    }
}
于 2008-10-22T13:43:23.090 に答える
4

1 つのイベントに登録し、イベント ハンドラーですべての追加と削除を処理したかったので、少し異なる方法でこれに取り組みました。コレクションの変更イベントをオーバーライドし、アイテムのリストを使用してリセット アクションを削除アクションにリダイレクトすることから始めました。観察可能なコレクションをコレクションビューのアイテムソースとして使用していて、「範囲アクションはサポートされていません」というメッセージが表示されたため、これはすべてうまくいきませんでした。

最後に、ビルトイン バージョンが動作することを期待した方法で動作する CollectionChangedRange という新しいイベントを作成しました。

なぜこの制限が許されるのか想像もつきませんが、この投稿が少なくとも他の人が私が行った行き止まりに陥るのを止めてくれることを願っています.

/// <summary>
/// An observable collection with support for addrange and clear
/// </summary>
/// <typeparam name="T"></typeparam>
[Serializable]
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ObservableCollectionRange<T> : ObservableCollection<T>
{
    private bool _addingRange;

    [field: NonSerialized]
    public event NotifyCollectionChangedEventHandler CollectionChangedRange;

    protected virtual void OnCollectionChangedRange(NotifyCollectionChangedEventArgs e)
    {
        if ((CollectionChangedRange == null) || _addingRange) return;
        using (BlockReentrancy())
        {
            CollectionChangedRange(this, e);
        }
    }

    public void AddRange(IEnumerable<T> collection)
    {
        CheckReentrancy();
        var newItems = new List<T>();
        if ((collection == null) || (Items == null)) return;
        using (var enumerator = collection.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                _addingRange = true;
                Add(enumerator.Current);
                _addingRange = false;
                newItems.Add(enumerator.Current);
            }
        }
        OnCollectionChangedRange(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newItems));
    }

    protected override void ClearItems()
    {
        CheckReentrancy();
        var oldItems = new List<T>(this);
        base.ClearItems();
        OnCollectionChangedRange(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, oldItems));
    }

    protected override void InsertItem(int index, T item)
    {
        CheckReentrancy();
        base.InsertItem(index, item);
        OnCollectionChangedRange(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
    }

    protected override void MoveItem(int oldIndex, int newIndex)
    {
        CheckReentrancy();
        var item = base[oldIndex];
        base.MoveItem(oldIndex, newIndex);
        OnCollectionChangedRange(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, item, newIndex, oldIndex));
    }

    protected override void RemoveItem(int index)
    {
        CheckReentrancy();
        var item = base[index];
        base.RemoveItem(index);
        OnCollectionChangedRange(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
    }

    protected override void SetItem(int index, T item)
    {
        CheckReentrancy();
        var oldItem = base[index];
        base.SetItem(index, item);
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, oldItem, item, index));
    }
}

/// <summary>
/// A read only observable collection with support for addrange and clear
/// </summary>
/// <typeparam name="T"></typeparam>
[Serializable]
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ReadOnlyObservableCollectionRange<T> : ReadOnlyObservableCollection<T>
{
    [field: NonSerialized]
    public event NotifyCollectionChangedEventHandler CollectionChangedRange;

    public ReadOnlyObservableCollectionRange(ObservableCollectionRange<T> list) : base(list)
    {
        list.CollectionChangedRange += HandleCollectionChangedRange;
    }

    private void HandleCollectionChangedRange(object sender, NotifyCollectionChangedEventArgs e)
    {
        OnCollectionChangedRange(e);
    }

    protected virtual void OnCollectionChangedRange(NotifyCollectionChangedEventArgs args)
    {
        if (CollectionChangedRange != null)
        {
            CollectionChangedRange(this, args);
        }
    }

}
于 2009-07-04T20:15:05.957 に答える
3

ObservableCollectionの要素にイベントハンドラーをアタッチおよびデタッチするシナリオでは、「クライアント側」ソリューションもあります。イベント処理コードでは、Containsメソッドを使用して、送信者がObservableCollectionにあるかどうかを確認できます。プロ:既存のObservableCollectionを操作できます。短所:ContainsメソッドはO(n)で実行されます。ここで、nはObservableCollection内の要素の数です。したがって、これは小さなObservableCollectionsのソリューションです。

もう1つの「クライアント側」ソリューションは、途中でイベントハンドラーを使用することです。すべてのイベントを途中のイベントハンドラーに登録するだけです。このイベントハンドラーは、コールバックまたはイベントを介して実際のイベントハンドラーに通知します。リセットアクションが発生した場合は、コールバックまたはイベントを削除し、途中で新しいイベントハンドラーを作成し、古いものを忘れてください。このアプローチは、大きなObservableCollectionsでも機能します。これをPropertyChangedイベントに使用しました(以下のコードを参照)。

    /// <summary>
    /// Helper class that allows to "detach" all current Eventhandlers by setting
    /// DelegateHandler to null.
    /// </summary>
    public class PropertyChangedDelegator
    {
        /// <summary>
        /// Callback to the real event handling code.
        /// </summary>
        public PropertyChangedEventHandler DelegateHandler;
        /// <summary>
        /// Eventhandler that is registered by the elements.
        /// </summary>
        /// <param name="sender">the element that has been changed.</param>
        /// <param name="e">the event arguments</param>
        public void PropertyChangedHandler(Object sender, PropertyChangedEventArgs e)
        {
            if (DelegateHandler != null)
            {
                DelegateHandler(sender, e);
            }
            else
            {
                INotifyPropertyChanged s = sender as INotifyPropertyChanged;
                if (s != null)
                    s.PropertyChanged -= PropertyChangedHandler;
            }   
        }
    }
于 2010-05-28T17:25:17.150 に答える
3

これがObservableCollectionの仕組みです。これを回避するには、ObservableCollectionの外部に独自のリストを保持し(アクションが[追加]の場合はリストに追加し、アクションが[削除]の場合は削除します)、すべての削除済みアイテム(または追加済みアイテム)を取得できます。 )リストをObservableCollectionと比較して、アクションがリセットされた場合。

もう1つのオプションは、IListとINotifyCollectionChangedを実装する独自のクラスを作成することです。次に、そのクラス内からイベントをアタッチおよびデタッチできます(または、必要に応じてOldItemsをClearに設定します)。これは実際には難しくありませんが、多くの入力が必要です。

于 2008-10-22T10:53:46.490 に答える
2

ObservableCollection と INotifyCollectionChanged インターフェイスは、特定の用途 (UI の構築とその特定のパフォーマンス特性) を念頭に置いて明確に記述されています。

コレクションの変更の通知が必要な場合は、通常、Add イベントと Remove イベントのみに関心があります。

次のインターフェイスを使用します。

using System;
using System.Collections.Generic;

/// <summary>
/// Notifies listeners of the following situations:
/// <list type="bullet">
/// <item>Elements have been added.</item>
/// <item>Elements are about to be removed.</item>
/// </list>
/// </summary>
/// <typeparam name="T">The type of elements in the collection.</typeparam>
interface INotifyCollection<T>
{
    /// <summary>
    /// Occurs when elements have been added.
    /// </summary>
    event EventHandler<NotifyCollectionEventArgs<T>> Added;

    /// <summary>
    /// Occurs when elements are about to be removed.
    /// </summary>
    event EventHandler<NotifyCollectionEventArgs<T>> Removing;
}

/// <summary>
/// Provides data for the NotifyCollection event.
/// </summary>
/// <typeparam name="T">The type of elements in the collection.</typeparam>
public class NotifyCollectionEventArgs<T> : EventArgs
{
    /// <summary>
    /// Gets or sets the elements.
    /// </summary>
    /// <value>The elements.</value>
    public IEnumerable<T> Items
    {
        get;
        set;
    }
}

Collection の独自のオーバーロードも作成しました。

  • ClearItems が発生します
  • InsertItem レイズが追加されました
  • RemoveItem が発生します
  • SetItem は削除と追加を発生させます

もちろん、AddRange も追加できます。

于 2010-07-13T12:18:28.053 に答える
2

NotifyCollectionChangedEventArgsを見ると、OldItemsには、Replace、Remove、または Move アクションの結果として変更されたアイテムのみが含まれているようです。クリアに何かが含まれていることを示すものではありません。Clear はイベントを発生させますが、削除されたアイテムを登録せず、Remove コードをまったく呼び出しません。

于 2008-10-22T01:35:26.803 に答える
2

さて、私は自分でそれを汚すことにしました。

Microsoft は、リセットを呼び出すときに NotifyCollectionChangedEventArgs にデータがないことを常に確認するために多くの作業を行いました。これはパフォーマンス/メモリの決定だったと思います。100,000 個の要素を含むコレクションをリセットする場合、それらの要素をすべて複製することは望んでいないと思います。

しかし、私のコレクションには 100 を超える要素が含まれていないため、問題はありません。

とにかく、次のメソッドで継承クラスを作成しました。

protected override void ClearItems()
{
    CheckReentrancy();
    List<TItem> oldItems = new List<TItem>(Items);

    Items.Clear();

    OnPropertyChanged(new PropertyChangedEventArgs("Count"));
    OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));

    NotifyCollectionChangedEventArgs e =
        new NotifyCollectionChangedEventArgs
        (
            NotifyCollectionChangedAction.Reset
        );

        FieldInfo field =
            e.GetType().GetField
            (
                "_oldItems",
                BindingFlags.Instance | BindingFlags.NonPublic
            );
        field.SetValue(e, oldItems);

        OnCollectionChanged(e);
    }
于 2009-10-01T19:10:11.753 に答える
1

簡単にするために、ClearItem メソッドをオーバーライドして、イベントからアイテムを切り離すなど、必要なことをすべて実行してみませんか。

public class PeopleAttributeList : ObservableCollection<PeopleAttributeDto>,    {
{
  protected override void ClearItems()
  {
    Do what ever you want
    base.ClearItems();
  }

  rest of the code omitted
}

シンプルでクリーンで、コレクション コード内に含まれています。

于 2011-12-28T20:12:50.653 に答える
1

Silverlight および WPF ツールキットのチャート作成コードを調べていたところ、この問題も (同様の方法で) 解決されていることに気付きました。

基本的に、派生した ObservableCollection も作成し、ClearItems をオーバーライドして、クリアされる各アイテムで Remove を呼び出します。

コードは次のとおりです。

/// <summary>
/// An observable collection that cannot be reset.  When clear is called
/// items are removed individually, giving listeners the chance to detect
/// each remove event and perform operations such as unhooking event 
/// handlers.
/// </summary>
/// <typeparam name="T">The type of item in the collection.</typeparam>
public class NoResetObservableCollection<T> : ObservableCollection<T>
{
    public NoResetObservableCollection()
    {
    }

    /// <summary>
    /// Clears all items in the collection by removing them individually.
    /// </summary>
    protected override void ClearItems()
    {
        IList<T> items = new List<T>(this);
        foreach (T item in items)
        {
            Remove(item);
        }
    }
}
于 2009-07-16T16:05:57.793 に答える
1

これは注目の話題です...私の意見では、マイクロソフトはその仕事を適切に行っていませんでした...またしても。誤解しないでほしいのですが、私は Microsoft が好きですが、Microsoft は完璧ではありません!

以前のコメントのほとんどを読みました。Microsoft が Clear() を適切にプログラムしなかったと考えるすべての人に同意します。

私の意見では、少なくとも、オブジェクトをイベントから切り離すことができるようにするための引数が必要です...しかし、その影響も理解しています。次に、この提案されたソリューションを考え出しました。

私はそれがすべての人、あるいは少なくともほとんどの人を幸せにすることを願っています...

エリック

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

namespace WpfUtil.Collections
{
    public static class ObservableCollectionExtension
    {
        public static void RemoveAllOneByOne<T>(this ObservableCollection<T> obsColl)
        {
            foreach (T item in obsColl)
            {
                while (obsColl.Count > 0)
                {
                    obsColl.RemoveAt(0);
                }
            }
        }

        public static void RemoveAll<T>(this ObservableCollection<T> obsColl)
        {
            if (obsColl.Count > 0)
            {
                List<T> removedItems = new List<T>(obsColl);
                obsColl.Clear();

                NotifyCollectionChangedEventArgs e =
                    new NotifyCollectionChangedEventArgs
                    (
                        NotifyCollectionChangedAction.Remove,
                        removedItems
                    );
                var eventInfo =
                    obsColl.GetType().GetField
                    (
                        "CollectionChanged",
                        BindingFlags.Instance | BindingFlags.NonPublic
                    );
                if (eventInfo != null)
                {
                    var eventMember = eventInfo.GetValue(obsColl);
                    // note: if eventMember is null
                    // nobody registered to the event, you can't call it.
                    if (eventMember != null)
                        eventMember.GetType().GetMethod("Invoke").
                            Invoke(eventMember, new object[] { obsColl, e });
                }
            }
        }
    }
}
于 2011-03-18T18:51:05.657 に答える
0

私は同じ問題を抱えていましたが、これが私の解決策でした。うまくいくようです。このアプローチに潜在的な問題があると考えている人はいますか?

// overriden so that we can call GetInvocationList
public override event NotifyCollectionChangedEventHandler CollectionChanged;

protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
    NotifyCollectionChangedEventHandler collectionChanged = CollectionChanged;
    if (collectionChanged != null)
    {
        lock (collectionChanged)
        {
            foreach (NotifyCollectionChangedEventHandler handler in collectionChanged.GetInvocationList())
            {
                try
                {
                    handler(this, e);
                }
                catch (NotSupportedException ex)
                {
                    // this will occur if this collection is used as an ItemsControl.ItemsSource
                    if (ex.Message == "Range actions are not supported.")
                    {
                        handler(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
                    }
                    else
                    {
                        throw ex;
                    }
                }
            }
        }
    }
}

私のクラスの他の便利なメソッドを次に示します。

public void SetItems(IEnumerable<T> newItems)
{
    Items.Clear();
    foreach (T newItem in newItems)
    {
        Items.Add(newItem);
    }
    NotifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}

public void AddRange(IEnumerable<T> newItems)
{
    int index = Count;
    foreach (T item in newItems)
    {
        Items.Add(item);
    }
    NotifyCollectionChangedEventArgs e = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<T>(newItems), index);
    NotifyCollectionChanged(e);
}

public void RemoveRange(int startingIndex, int count)
{
    IList<T> oldItems = new List<T>();
    for (int i = 0; i < count; i++)
    {
        oldItems.Add(Items[startingIndex]);
        Items.RemoveAt(startingIndex);
    }
    NotifyCollectionChangedEventArgs e = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, new List<T>(oldItems), startingIndex);
    NotifyCollectionChanged(e);
}

// this needs to be overridden to avoid raising a NotifyCollectionChangedEvent with NotifyCollectionChangedAction.Reset, which our other lists don't support
new public void Clear()
{
    RemoveRange(0, Count);
}

public void RemoveWhere(Func<T, bool> criterion)
{
    List<T> removedItems = null;
    int startingIndex = default(int);
    int contiguousCount = default(int);
    for (int i = 0; i < Count; i++)
    {
        T item = Items[i];
        if (criterion(item))
        {
            if (removedItems == null)
            {
                removedItems = new List<T>();
                startingIndex = i;
                contiguousCount = 0;
            }
            Items.RemoveAt(i);
            removedItems.Add(item);
            contiguousCount++;
        }
        else if (removedItems != null)
        {
            NotifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, startingIndex));
            removedItems = null;
            i = startingIndex;
        }
    }
    if (removedItems != null)
    {
        NotifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, startingIndex));
    }
}

private void NotifyCollectionChanged(NotifyCollectionChangedEventArgs e)
{
    OnPropertyChanged(new PropertyChangedEventArgs("Count"));
    OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
    OnCollectionChanged(e);
}
于 2013-11-21T01:31:12.963 に答える
0

ClearItems メソッドをオーバーライドし、Remove アクションと OldItems でイベントを発生させることができます。

public class ObservableCollection<T> : System.Collections.ObjectModel.ObservableCollection<T>
{
    protected override void ClearItems()
    {
        CheckReentrancy();
        var items = Items.ToList();
        base.ClearItems();
        OnPropertyChanged(new PropertyChangedEventArgs("Count"));
        OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, items, -1));
    }
}

実現の一部System.Collections.ObjectModel.ObservableCollection<T>:

public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged
{
    protected override void ClearItems()
    {
        CheckReentrancy();
        base.ClearItems();
        OnPropertyChanged(CountString);
        OnPropertyChanged(IndexerName);
        OnCollectionReset();
    }

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

    private void OnCollectionReset()
    {
        OnCollectionChanged(new   NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }

    private const string CountString = "Count";

    private const string IndexerName = "Item[]";
}
于 2015-09-18T10:59:33.627 に答える
0

ObservableCollection から派生した別の「シンプルな」ソリューションを見つけましたが、リフレクションを使用しているため、あまりエレガントではありません...気に入った場合は、ここに私のソリューションがあります:

public class ObservableCollectionClearable<T> : ObservableCollection<T>
{
    private T[] ClearingItems = null;

    protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        switch (e.Action)
        {
            case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
                if (this.ClearingItems != null)
                {
                    ReplaceOldItems(e, this.ClearingItems);
                    this.ClearingItems = null;
                }
                break;
        }
        base.OnCollectionChanged(e);
    }

    protected override void ClearItems()
    {
        this.ClearingItems = this.ToArray();
        base.ClearItems();
    }

    private static void ReplaceOldItems(System.Collections.Specialized.NotifyCollectionChangedEventArgs e, T[] olditems)
    {
        Type t = e.GetType();
        System.Reflection.FieldInfo foldItems = t.GetField("_oldItems", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
        if (foldItems != null)
        {
            foldItems.SetValue(e, olditems);
        }
    }
}

ここでは、現在の要素を ClearItems メソッドの配列フィールドに保存してから、OnCollectionChanged の呼び出しをインターセプトし、base.OnCollectionChanged を起動する前に (リフレクションを介して) e._oldItems プライベート フィールドを上書きします。

于 2014-08-27T14:09:13.817 に答える
-4

http://msdn.microsoft.com/en-us/library/system.collections.specialized.notifycollectionchangedaction(VS.95).aspx

目を開けて頭をオンにして、このドキュメントを読んでください。マイクロソフトはすべてを正しく行いました。リセット通知がスローされたら、コレクションを再スキャンする必要があります。アイテムごとに Add/Remove をスローする (コレクションから削除され、再びコレクションに追加される) のはコストがかかりすぎるため、リセット通知を受け取ります。

オリオン・エドワーズは完全に正しいです(尊敬、男)。ドキュメントを読むときは、より広く考えてください。

于 2011-04-06T13:48:52.250 に答える