¿Cómo puedo hacer que un eventhandler se ejecute de forma asíncrona?

Además, si no quiero pasar ningún parámetro al controlador de eventos, ¿mi sintaxis es correcta usando OperationFinished(null, new EventArgs()) ?

No. Por lo general, lo llamarías como:

OperationFinished(this, EventArgs.Empty);

Siempre debe pasar un objeto como remitente - se espera en el patrón (aunque normalmente se ignora). EventArgs.Empty también es mejor que new EventArgs ().

Para disparar esto en un hilo separado, la opción más fácil es probablemente usar el grupo de temas:

private void RaiseOperationFinished()
{
       ThreadPool.QueueUserWorkItem( new WaitCallback( (s) =>
           {
              if (this.OperationFinished != null)
                   this.OperationFinished(this, EventArgs.Empty);
           }));
}

Dicho esto, elevar un evento en un hilo separado es algo que debe documentarse a fondo, ya que potencialmente causará un comportamiento inesperado.

Con la Biblioteca Paralela de Tareas ahora es posible hacer lo siguiente:

Task.Factory.FromAsync( ( asyncCallback, @object ) => this.OperationFinished.BeginInvoke( this, EventArgs.Empty, asyncCallback, @object ), this.OperationFinished.EndInvoke, null );

Pruebe los métodos BeginInvoke y EndInvoke en el delegado de evento - estos regresan inmediatamente, y le permiten usar polling, un controlador de espera o una función de devolución de llamada para notificarle cuando el método se ha completado. Vea aquí para una descripción general; en su ejemplo, el evento es el delegado que usará

Tal vez Method2 o Method3 a continuación puede ayudar:)

public partial class Form1 : Form
{
    private Thread SecondaryThread;

    public Form1()
    {
        InitializeComponent();

        OperationFinished += callback1;
        OperationFinished += callback2;
        OperationFinished += callback3;
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        SecondaryThread = new Thread(new ThreadStart(SecondaryThreadMethod));
        SecondaryThread.Start();
    }

     private void SecondaryThreadMethod()
     {
        Stopwatch sw = new Stopwatch();
        sw.Restart();

        OnOperationFinished(new MessageEventArg("test1"));
        OnOperationFinished(new MessageEventArg("test2"));
        OnOperationFinished(new MessageEventArg("test3"));
        //This is where the program waits for whatever operations take
             //place when OperationFinished is triggered.

        sw.Stop();

        Invoke((MethodInvoker)delegate
        {
            richTextBox1.Text += "Time taken (ms): " + sw.ElapsedMilliseconds + "\n";
        });
     }

    void callback1(object sender, MessageEventArg e)
    {
        Thread.Sleep(2000);
        Invoke((MethodInvoker)delegate
        {
            richTextBox1.Text += e.Message + "\n";
        });
    }
    void callback2(object sender, MessageEventArg e)
    {
        Thread.Sleep(2000);
        Invoke((MethodInvoker)delegate
        {
            richTextBox1.Text += e.Message + "\n";
        });
    }

    void callback3(object sender, MessageEventArg e)
    {
        Thread.Sleep(2000);
        Invoke((MethodInvoker)delegate
        {
            richTextBox1.Text += e.Message + "\n";
        });
    }

    public event EventHandler<MessageEventArg> OperationFinished;

    protected void OnOperationFinished(MessageEventArg e)
    {
        //##### Method1 - Event raised on the same thread ##### 
        //EventHandler<MessageEventArg> handler = OperationFinished;

        //if (handler != null)
        //{
        //    handler(this, e);
        //}

        //##### Method2 - Event raised on (the same) separate thread for all listener #####
        //EventHandler<MessageEventArg> handler = OperationFinished;

        //if (handler != null)
        //{
        //    Task.Factory.StartNew(() => handler(this, e));
        //}

        //##### Method3 - Event raised on different threads for each listener #####
        if (OperationFinished != null)
        {
            foreach (EventHandler<MessageEventArg> handler in OperationFinished.GetInvocationList())
            {
                Task.Factory.FromAsync((asyncCallback, @object) => handler.BeginInvoke(this, e, asyncCallback, @object), handler.EndInvoke, null);
            }
        }
    }
}

public class MessageEventArg : EventArgs
{
    public string Message { get; set; }

    public MessageEventArg(string message)
    {
        this.Message = message;
    }
}

}

Prefiero definir un método que paso al subproceso hijo como un delegado que actualiza la interfaz de usuario. Primero defina un delegado:

public delegate void ChildCallBackDelegate();

En el subproceso hijo defina un miembro delegado:

public ChildCallbackDelegate ChildCallback {get; set;}

En la clase que llama defina el método que actualiza la interfaz de usuario. Tendrás que envolverlo en el despachador del control de destino ya que se llama desde un subproceso separado. Nota el BeginInvoke. En este contexto no se requiere EndInvoke:

private void ChildThreadUpdater()
{
  yourControl.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background
    , new System.Threading.ThreadStart(delegate
      {
        // update your control here
      }
    ));
}

Antes de iniciar el subproceso hijo, configure su propiedad ChildCallBack:

theChild.ChildCallBack = new ChildCallbackDelegate(ChildThreadUpdater);

Entonces cuando el subproceso hijo quiere actualizar el padre:

ChildCallBack();

Mira la clase BackgroundWorker. Creo que hace exactamente lo que usted está pidiendo.

EDITAR: Lo que creo que estás preguntando es cómo disparar un evento cuando solo una pequeña parte de la tarea de fondo general está completa. BackgroundWorker proporciona un evento llamado "ProgressChanged" que le permite informar al hilo principal que alguna parte del proceso general está completa. Luego, cuando todo el trabajo asincrónico se completa, se genera el evento" RunWorkerCompleted".