BlockReentrancy in ObservableCollection<T>

Könnte bitte jemand so freundlich, mir zu erklären, was der Zweck der BlockReentrancy Methode ist in der ObservableCollection<T> ?

MSDN zeigt Folgendes Beispiel:

//The typical usage is to wrap an OnCollectionChanged call within a using scope, as in the following example:

using (BlockReentrancy())
{
    //OnCollectionChanged call
}

Aber das scheint nicht zu klären für mich, was der Zweck ist. Jemand darauf zu erklären?

  • Aussprechen BlockReëntrancy
  • Zusätzlich zu den akzeptierten Antworten, ist es erwähnenswert, dass using (BlockReentrancy()) {} ist auch erforderlich im multi-threaded Fall verwenden, wenn die Sammlung aktualisiert, so Häufig, dass es zu überschneidungen mit der OnCollectionChanged Verarbeitung. Dies kann möglicherweise passieren, mit nur einem einzelnen XAML-unverbindlich und ohne weitere explizite Abonnenten in der benutzerdefinierten code.
InformationsquelleAutor Maxim Gershkovich | 2011-06-06
  1. 27

    Einer ObservableCollection implementiert INotifyCollectionChanged und so hat es eine CollectionChanged Veranstaltung. Wenn es ein Teilnehmer an dieser Veranstaltung, konnten Sie weiter ändern die Kollektion, die Sammlung ist bereits in den Prozess der Benachrichtigung. Da die CollectionChanged Veranstaltung verfolgt genau, was sich geändert hat, diese Interaktion kann sehr chaotisch.

    Als Ergebnis der ObservableCollection ermöglicht, als ein spezieller Fall eines einzigen Abonnenten der CollectionChanged Veranstaltung zu ändern, die Sammlung von seinem handler. Aber es verbietet änderung der Auflistung von CollectionChanged handler wenn es zwei oder mehr Abonnenten der CollectionChanged Veranstaltung.

    Den beiden Methoden BlockReentrancy und CheckReentancy werden verwendet, um die Umsetzung dieser Logik. Die BlockReentrancy ist am Anfang der OnCollectionChanged Methode und CheckReentancy wird in allen Methoden, die zur Veränderung der Sammlung.

    • Es dient der Unterstützung von Thread-Sicherheit?
    • Sehr interessant, dass die MSDN-Dokumentation nicht zu erwähnen, diese kleine Tatsache, dass CheckReentrancy verhindern Reentranz nur, wenn es mehr als ein Handler angebracht, um das CollectionChanged-Ereignis.
    • "es verbietet eine änderung der Auflistung von den CollectionChanged-handler, wenn es zwei oder mehr Abonnenten für das CollectionChanged-Ereignis." Was, wenn es nur ein Abonnent, aber es gibt zwei worker-threads eine änderung der Auflistung? In diesem Fall sollte ich andere sperren zum sperren der Operationen wie Einfügen und Löschen und auch sperren, die OnCollectionChanged handler?
    InformationsquelleAutor Rick Sladkey
  2. 12

    Dies ist die Realisierung der BlockReentrancy()

    protected IDisposable BlockReentrancy()
{
   this._monitor.Enter();
   return this._monitor;
}

    Gibt es eine andere Methode CheckReentrancy()

    protected void CheckReentrancy()
{
    if ((this._monitor.Busy && (this.CollectionChanged != null)) && (this.CollectionChanged.GetInvocationList().Length > 1))
    {
        throw new InvalidOperationException(SR.GetString("ObservableCollectionReentrancyNotAllowed"));
    }
}

    Methoden wie ClearItems, InsertItem, MoveItem, RemoveItem, SetItem überprüfen CheckReentrancy() vor dem ändern Sammlung.

    Also den code unten garantiert, dass die collection nicht geändert werden, innerhalb von using, aber nur, wenn es mehr als ein handler abonniert CollectionChanged Veranstaltung.

    using BlockReentrancy())
{
    CollectionChanged(this, e);
}

    Dieses Beispiel veranschaulicht die Wirkung von BlockReentrancy()

    private static void Main()
{
    collection.CollectionChanged += CollectionCollectionChanged1;
    collection.CollectionChanged += CollectionCollectionChanged2;
    collection.Add(1);
}

private static void CollectionCollectionChanged1(object sender, NotifyCollectionChangedEventArgs e)
{
    collection.Add(2); //this line will throw exception
}

private static void CollectionCollectionChanged2(object sender, NotifyCollectionChangedEventArgs e)
{
}
    • Ihre demonstration code werfen wird StackOverflowException keine InvalidOperationException. In diesem Fall Reentranz wird nicht überprüft. Siehe meine Antwort.
    • Sladkey - sind Sie richtig.
    InformationsquelleAutor Alex Aza
  3. 3

    Reentranz ist, wenn eine Methode etwas tut, direkt oder indirekt, die bewirkt, dass die Methode erneut aufgerufen werden, möglicherweise rekursiv. In diesem Fall wird die using-block verwendet werden soll innerhalb der OnCollectionChanged delegieren, wenn Sie verhindern möchten, dass der Wechsel von der Sammlung innerhalb des handlers; versuche, es zu ändern, wird eine Ausnahme ausgelöst. Wenn Sie es nicht verwenden, dann alle versuche, ändern Sie die Sammlung führen würde OnCollectionChanged werden erneut aufgerufen.

    InformationsquelleAutor x0n
  4. 1

    Unten ist die code hinter BlockReentrancy. CheckReentrancy heißt am Anfang jeder Kollektion modifier-Methode in der Implementierung von ObservableCollection.

        ///<summary>
    ///Disallow reentrant attempts to change this collection. E.g. an event handler
    ///of the CollectionChanged event is not allowed to make changes to this collection.
    ///</summary>
    ///<remarks>
    ///typical usage is to wrap e.g. a OnCollectionChanged call with a using() scope:
    ///<code>
    ///        using (BlockReentrancy())
    ///        {
    ///            CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, item, index));
    ///        }
    ///</code>
    ///</remarks>
    protected IDisposable BlockReentrancy()
    {
        _blockReentrancyCount++;
        return EnsureMonitorInitialized();
    }

    ///<summary> Check and assert for reentrant attempts to change this collection. </summary>
    ///<exception cref="InvalidOperationException"> raised when changing the collection
    ///while another collection change is still being notified to other listeners </exception>
    protected void CheckReentrancy()
    {
        if (_blockReentrancyCount > 0)
        {
            //we can allow changes if there's only one listener - the problem
            //only arises if reentrant changes make the original event args
            //invalid for later listeners.  This keeps existing code working
            //(e.g. Selector.SelectedItems).
            if (CollectionChanged?.GetInvocationList().Length > 1)
                throw new InvalidOperationException(SR.ObservableCollectionReentrancyNotAllowed);
        }
    }

    private SimpleMonitor EnsureMonitorInitialized()
    {
        return _monitor ?? (_monitor = new SimpleMonitor(this));
    }

    (Copyright (c) .NET Foundation und Mitwirkende)

    InformationsquelleAutor Mike DeMauro
Schreibe einen Kommentar