Ordem de execução do manipulador de eventos

Se eu configurar vários manipuladores de eventos, como:

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

em que ordem os manipuladores são executados quando o evento RetrieveDataCompletedé disparado? Eles são executados no mesmo thread e sequencialmente na ordem em que são registrados?

Atualmente, eles são executados na ordem em que são registrados. No entanto, este é um detalhe de implementação, e eu não confiaria que esse comportamento permanecesse o mesmo em versões futuras, uma vez que não é exigido pelas especificações.

A lista de invocação de um delegado é um conjunto ordenado de delegados em que cada elemento da lista invoca exatamente um dos métodos invocados pelo delegado. Uma lista de invocação pode conter métodos duplicados. Durante uma invocação, um delegado invoca métodos na ordem em que aparecem na lista de invocação .

A partir daqui: classe de delegados

Você pode alterar a ordem desanexando todos os manipuladores e, em seguida, reconectando na ordem desejada.

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

A ordem é arbitrária. Você não pode contar com os manipuladores sendo executados em qualquer ordem específica de uma chamada para a próxima.

Edit: E também - a menos que seja apenas por curiosidade - o fato de que você precisa saber é indicativo de um sério problema de design.

Eles são executados na ordem em que são registrados. RetrieveDataCompletedé um Multicast Delegates . Estou olhando pelo refletor para tentar verificar, e parece que um array é usado nos bastidores para controlar tudo.

Se alguém precisar fazer isso no contexto de um System.Windows.Forms.Form, aqui está um exemplo invertendo a ordem do evento Mostrado.

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

Um MulticastDelegate tem uma lista vinculada de delegados, chamada de lista de invocação, que consiste em um ou mais elementos. Quando um delegado multicast é invocado, os delegados na lista de invocação são chamados de forma síncrona na ordem em que aparecem. Se ocorrer um erro durante a execução da lista, uma exceção será lançada.

Durante uma chamada, os métodos são chamados na ordem em que aparecem na lista de chamadas.

Mas ninguém diz que a lista de invocação mantém os delegados na mesma ordem em que são adicionados. Assim, a ordem de invocação não é garantida.

Esta é uma função que colocará a nova função do manipulador de eventos onde você quiser na lista de invocação multidelegate.

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

Então você sempre pode remover a função com um '- =' em qualquer lugar do seu código.

PS - Não estou tratando de erros para o parâmetro 'posição'.

Eu tive um problema parecido. No meu caso, foi corrigido muito facilmente. Eu nunca tinha visto um delegado que não usasse o operador + =. Meu problema foi resolvido por ter um delegado sempre adicionado no final, todos os outros são sempre adicionados no início. O exemplo do OP seria algo como:

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

No primeiro caso, ProcessData1 será chamado por último. No segundo caso, ProcessData2 será chamado primeiro.