Reihenfolge der Ausführung des Ereignishandlers

Wenn ich mehrere Ereignishandler einrichte, wie folgt:

_webservice.RetrieveDataCompleted += ProcessData1;
_webservice.RetrieveDataCompleted += ProcessData2;

In welcher Reihenfolge werden die Handler ausgeführt, wenn das Ereignis RetrieveDataCompletedausgelöst wird? Werden sie im selben Thread und nacheinander in der Reihenfolge ausgeführt, in der sie registriert sind?

Derzeit werden sie in der Reihenfolge ausgeführt, in der sie registriert sind. Dies ist jedoch ein Implementierungsdetail, und ich würde mich nicht darauf verlassen, dass dieses Verhalten in zukünftigen Versionen gleich bleibt, da es von den Spezifikationen nicht verlangt wird.

Die Aufrufliste eines Delegaten ist eine geordnete Gruppe von Delegaten, in der jedes Element der Liste genau eine der vom Delegaten aufgerufenen Methoden aufruft. Eine Aufrufliste kann doppelte Methoden enthalten. Während eines Aufrufs ruft ein Delegat Methoden in der Reihenfolge auf, in der sie in der Aufrufliste angezeigt werden .

Von hier aus: Delegiertenklasse

Sie können die Reihenfolge ändern, indem Sie alle Handler abnehmen und dann in der gewünschten Reihenfolge wieder anbringen.

public event EventHandler event1;

public void ChangeHandlersOrdering()
{
    if (event1 != null)
    {
        List<EventHandler> invocationList = event1.GetInvocationList()
                                                  .OfType<EventHandler>()
                                                  .ToList();

        foreach (var handler in invocationList)
        {
            event1 -= handler;
        }

        //Change ordering now, for example in reverese order as follows
        for (int i = invocationList.Count - 1; i >= 0; i--)
        {
            event1 += invocationList[i];
        }
    }
}

Die Reihenfolge ist beliebig. Sie können sich nicht darauf verlassen, dass die Handler von einem Aufruf zum nächsten in einer bestimmten Reihenfolge ausgeführt werden.

Bearbeiten: Und auch - es sei denn, dies ist nur aus Neugier - die Tatsache, dass Sie wissen müssen, weist auf ein ernstes Designproblem hin.

Sie werden in der Reihenfolge ausgeführt, in der sie registriert sind. RetrieveDataCompletedist ein Multicast-Delegierter . Ich schaue durch den Reflektor, um zu überprüfen, und es sieht so aus, als würde hinter den Kulissen ein Array verwendet, um alles im Auge zu behalten.

Wenn jemand dies im Kontext eines System.Windows.Forms.Form tun muss, finden Sie hier ein Beispiel, das die Reihenfolge des angezeigten Ereignisses invertiert.

using System;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Windows.Forms;

namespace ConsoleApplication {
    class Program {
        static void Main() {
            Form form;

            form = createForm();
            form.ShowDialog();

            form = createForm();
            invertShownOrder(form);
            form.ShowDialog();
        }

        static Form createForm() {
            var form = new Form();
            form.Shown += (sender, args) => { Console.WriteLine("form_Shown1"); };
            form.Shown += (sender, args) => { Console.WriteLine("form_Shown2"); };
            return form;
        }

        static void invertShownOrder(Form form) {
            var events = typeof(Form)
                .GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(form, null) as EventHandlerList;

            var shownEventKey = typeof(Form)
                .GetField("EVENT_SHOWN", BindingFlags.NonPublic | BindingFlags.Static)
                .GetValue(form);

            var shownEventHandler = events[shownEventKey] as EventHandler;

            if (shownEventHandler != null) {
                var invocationList = shownEventHandler
                    .GetInvocationList()
                    .OfType<EventHandler>()
                    .ToList();

                foreach (var handler in invocationList) {
                    events.RemoveHandler(shownEventKey, handler);
                }

                for (int i = invocationList.Count - 1; i >= 0; i--) {
                    events.AddHandler(shownEventKey, invocationList[i]);
                }
            }
        }
    }
}

Ein MulticastDelegate verfügt über eine verknüpfte Liste von Delegaten, die als Aufrufliste bezeichnet wird und aus einem oder mehreren Elementen besteht. Wenn ein Multicast-Delegat aufgerufen wird, werden die Delegaten in der Aufrufliste synchron in der Reihenfolge aufgerufen, in der sie angezeigt werden. Wenn während der Ausführung der Liste ein Fehler auftritt, wird eine Ausnahme ausgelöst.

Während eines Aufrufs werden Methoden in der Reihenfolge aufgerufen, in der sie in der Aufrufliste angezeigt werden.

Aber niemand sagt, dass die Aufrufliste die Delegierten in derselben Reihenfolge verwaltet, in der sie hinzugefügt wurden. Somit ist die Aufrufreihenfolge nicht garantiert.

Dies ist eine Funktion, mit der die neue Ereignishandlerfunktion an einer beliebigen Stelle in der Aufrufliste mit mehreren Registern platziert wird.

    private void addDelegateAt(ref YourDelegate initial, YourDelegate newHandler, int position)
    {
        Delegate[] subscribers = initial.GetInvocationList();
        Delegate[] newSubscriptions = new Delegate[subscribers.Length + 1];

        for (int i = 0; i < newSubscriptions.Length; i++)
        {
            if (i < position)
                newSubscriptions[i] = subscribers[i];
            else if (i==position)
                newSubscriptions[i] = (YourDelegate)newHandler;
            else if (i > position)
                newSubscriptions[i] = subscribers[i-1];
        }

        initial = (YourDelegate)Delegate.Combine(newSubscriptions);
    }

Dann können Sie die Funktion jederzeit mit einem '- =' entfernen, wo immer dies in Ihrem Code zweckmäßig ist.

PS - Ich mache keine Fehlerbehandlung für den Parameter 'position'.

Ich hatte ein ähnliches Problem. In meinem Fall war es sehr einfach zu beheben. Ich hatte noch nie einen Delegierten gesehen, der den Operator + = nicht verwendete. Mein Problem wurde behoben, indem immer ein Delegierter am Ende hinzugefügt wurde, alle anderen immer am Anfang. Das Beispiel des OP wäre ungefähr so:

    _webservice.RetrieveDataCompleted = _webservice.RetrieveDataCompleted + ProcessData1;
    _webservice.RetrieveDataCompleted = ProcessData2 + _webservice.RetrieveDataCompleted;

Im ersten Fall wird ProcessData1 zuletzt aufgerufen. Im zweiten Fall wird ProcessData2 zuerst aufgerufen.