Custom Events em C#

Segue um exemplo sobre como criar eventos personalizados em C# e usá-los para realizar ações assim que um processamento mais demorado for concluído, deixando a thread principal da aplicação livre para outros trabalhos.

(This is a sample application written in C# that demonstrates how to trigger some action when an expensive function finishes its job.)

Para testar, basta criar uma aplicação do tipo console com o código abaixo:

using System;
using System.Threading;

namespace ConsoleApplication1
{
  class Program
  {
      static void Main(string[] args)
      {
          for (int myNum = 0; myNum ‹ 5; myNum++)
          {
              // Objeto de teste
              CTest ct = new CTest();

              // Método que será executado após o
                // término do processamento demorado.
              ct.TestCompleted += new CTest.TestEventHandler(
                  ct_TestCompleted);

              // Roda o método demorado, liberando
                // a aplicação principal.
              new Thread(new ParameterizedThreadStart(
                  ct.Test)).Start(myNum);
          }
      }

      // Sinaliza o término da tarefa.
      static void ct_TestCompleted(
          object sender, CTest.TestEventArgs e)
      {
          // Os parâmetros estarão no objeto (e)
          Console.WriteLine("Completed: " + e.j);
      }
  }

  class CTest
  {
      // Este é o método demorado.
        // "myNum" Apenas identifica as threads.
      public void Test(object myNum)
      {
          // Sinaliza o início da tarefa
          Console.WriteLine("Starting: " + myNum);

          // Simula um processamento demorado
          Thread.Sleep(3000);
        
          // Dispara o evento ao terminar
          RaiseTestCompleted((int)myNum);
      }

      // Nesta classe são definidos
        // objetos para uso posterior.
      public class TestEventArgs : System.EventArgs
      {
          public int j; // um exemplo
          public TestEventArgs(int j)
          {
              this.j = j;
          }
      }

      // Declaração de um delegate
        // e um evento auxiliares
      public delegate void TestEventHandler(
          object sender, TestEventArgs e);

      public event TestEventHandler TestCompleted;

      // Este método prepara os parâmetros
        // e dispara o evento assíncrono.
      private void RaiseTestCompleted(int j)
      {
          TestEventArgs args = new TestEventArgs(j);
          OnTest(this, args);
      }

      protected virtual void OnTest(
          object sender, TestEventArgs e)
      {
          if (TestCompleted != null)
              TestCompleted(this, e);
      }
  }
}

Em passos gerais, é criada uma classe TestEventArgs com os objetos que serão expostos via argumentos da função executada logo após o término do processamento demorado.

Neste exemplo, disparo 5 threads que demoram alguns segundos. Note que, devido à concorrência do sistema, ocasionalmente elas podem finalizar fora de ordem.

Talvez um pouco confuso à primeira vista, mas muito útil em diversas aplicações.