Ordine di esecuzione del gestore eventi

Se imposto più gestori di eventi, in questo modo:

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

in che ordine vengono eseguiti i gestori quando RetrieveDataCompletedviene generato l'evento ? Vengono eseguiti nello stesso thread e in sequenza nell'ordine in cui sono registrati?

Attualmente vengono eseguiti nell'ordine in cui sono registrati. Tuttavia, questo è un dettaglio di implementazione e non farei affidamento sul fatto che questo comportamento rimanga lo stesso nelle versioni future, poiché non è richiesto dalle specifiche.

L'elenco di chiamate di un delegato è un insieme ordinato di delegati in cui ogni elemento dell'elenco richiama esattamente uno dei metodi richiamati dal delegato. Un elenco di chiamate può contenere metodi duplicati. Durante una chiamata, un delegato richiama i metodi nell'ordine in cui vengono visualizzati nell'elenco di chiamate .

Da qui: Delegate Class

È possibile modificare l'ordine scollegando tutti i gestori e quindi ricollegandoli nell'ordine desiderato.

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];
        }
    }
}

L'ordine è arbitrario. Non puoi fare affidamento sul fatto che i gestori vengano eseguiti in un ordine particolare da una chiamata all'altra.

Modifica: E anche, a meno che non sia solo per curiosità, il fatto che devi sapere è indicativo di un serio problema di progettazione.

Vengono eseguiti nell'ordine in cui sono registrati. RetrieveDataCompletedè un Multicast Delegates . Sto guardando attraverso il riflettore per provare a verificare e sembra che un array venga utilizzato dietro le quinte per tenere traccia di tutto.

Se qualcuno ha bisogno di farlo nel contesto di un System.Windows.Forms.Form, ecco un esempio che inverte l'ordine dell'evento Shown.

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]);
                }
            }
        }
    }
}

Un MulticastDelegate dispone di un elenco collegato di delegati, denominato elenco di chiamate, costituito da uno o più elementi. Quando viene richiamato un delegato multicast, i delegati nell'elenco di chiamate vengono chiamati in modo sincrono nell'ordine in cui vengono visualizzati. Se si verifica un errore durante l'esecuzione dell'elenco, viene generata un'eccezione.

Durante una chiamata, i metodi vengono richiamati nell'ordine in cui sono visualizzati nell'elenco delle chiamate.

Ma nessuno dice che l'elenco di chiamate mantiene i delegati nello stesso ordine in cui vengono aggiunti. Pertanto, l'ordine di invocazione non è garantito.

Questa è una funzione che posizionerà la nuova funzione di gestore di eventi dove vuoi nell'elenco di chiamate a più eventi.

    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);
    }

Quindi puoi sempre rimuovere la funzione con un '- =' ovunque nel tuo codice sia conveniente.

PS - Non sto eseguendo alcuna gestione degli errori per il parametro "position".

Ho avuto un problema simile. Nel mio caso è stato risolto molto facilmente. Non avevo mai visto un delegato che non usasse l'operatore + =. Il mio problema è stato risolto aggiungendo sempre un delegato alla fine, tutti gli altri vengono sempre aggiunti all'inizio. L'esempio dell'OP sarebbe qualcosa del tipo:

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

Nel primo caso ProcessData1 sarà chiamato per ultimo. Nel 2 ° caso ProcessData2 sarà chiamato per primo.