manejar eventos

Hola Erick...

La misma documentación del SDK del .NET Framework puede
servirte para aprender los conceptos básicos... pero si
te sirve como una introducción ahi te va esto...

La base de los eventos son los delegados o "delegates".
Un delegado es una estructura de datos especial que sirve
para invocar funciones, algo asi como un apuntador a
funciones al estilo C++ y los eventos son delegados que
saben que funciones se van a invocar bajo una situación
determinada. Yo se que este tema es un poco complicado
porque a mi me costo un poco entenderlo bien, asi que
trataré de explicarme más con un ejemplo:

Supongamos que tenemos una clase que se encarga de
imprimir facturas llamada InvoicePrinter y que los
objetos de la clase CashierSupervisor (Supervisor de
cajeros) necesitan recibir una notificación cada ves que
un objeto Cashier (Cajero) imprime una factura. El código
en C# se vería más o menos asi (no me he metido con
VB.NET, me gustó más C#):

// Clase con información de una factura
// Archivo Invoice.cs
namespace InvoiceManager
{
public class Invoice
{
public int Number;
.
.
.
}
}

// Clase con información del evento
// que hereda de la clase System.EventArgs
// Archivo EventInfo.cs
namespace InvoiceManager
{
public class InvoicePrintedEventArgs : System.EventArgs
{
public readonly Invoice InvoiceInfo;

public InvoicePrintedEventArgs(Invoice invInfo)
{
InvoiceInfo = invInfo;
}
}
}

// Delegado que establece el formato (firma) de las
// funciones que serán manejadoras del evento,
// es decir, el tipo de devolución (void)
// y los parámetros (un tipo object que es quien
// dispara el evento y un derivado de System.EventArgs
// que contiene información relativa al evento)
// Archivo EventInfo.cs
namespace InvoiceManager
{
// Junto a la declaración de la clase
// InvoicePrintedEventArgs
public delegate void InvoicePrintedEventHandler(object
sender, InvoicePrintedEventArgs e);
}

// Clase InvoicePrinter que contiene el evento
// Archiov InvoicePrinter.cs
namespace InvoiceManager
{
public class InvoicePrinter
{
.
.
// Indica que el evento InvoicePrinted es del tipo
// del delegado InvoicePrintedEventHandler
// lo que significa que las funciones manejadoras
// deben cumplir con ese formato

public event InvoicePrintedEventHandler InvoicePrinted;

public void PrintInvoice(Invoice invoiceToPrint)
{
// Código para imprimir

// Si se han asociado manejadores al evento
if(InvoicePrinted != null)
{
InvoicePrintedEventArgs e;
e = new InvoicePrintedEventArgs(invoiceToPrint);
// A continuación se invocan las funciones
// asociadas como manejadoras de evento
// mediante la invoación del delegado
InvoicePrinted(this, e);
// 'this' hace referencia al objeto que dispara
// el evento y 'e' contiene la información
// relativa al evento, en este caso, la factura
// que se imprimió
}
}
}
}

// Clase con información del cajero
// Archivo Cashier.cs

namespace InvoiceManager
{
public class Cashier
{
.
.
public void PrintInvoice(InvoicePrinter invPrn,
Invoice inv)
{
invPrn.PrintInvoice(inv);
// Al invocar invPrint.PrintInvoice(inv);
// se dispara el evento...
}
}
}

// Y ahora la clase consumidora del evento
// Archivo CashierSupervisor.cs
namespace InvoiceManager
{
public class CashierSupervisor
{
private InvoicePrinter invPrinter;
.
.
public InvoicePrinter()
{
// El objeto invPrinter se instancia en el
// constructor de la clase
invPrinter = new InvoicePrinter();
// Con la siguiente linea se asocia al método
// OnInvoicePrinted como manejador del evento
// InvoicePrinted mediante '+=', esto es,
// que agregue el manejador a la lista de
// manejadores, por que un evento puede tener
// mas de un manejador asociado
invPrinter.InvoicePrinted += new
InvoicePrintedEventHandler(this.OnInvoicePrinted);
}

// Se define una propiedad de solo lectura para
// hacer publico a invPrinter
public InvoicePrinter InvoPrinter
{
get { return invPrinter; }
}

// Método manejador del evento
// que cumple con el formato establecido por el
// delegado. A diferencia de VB6 en los lenguajes .NET
// no hay restricción para el nombre del método
// manejador del evento
private void OnInvoicePrinted(object sender,
InvoicePrintedEventArgs e)
{
// Realizar acciones pertinentes, como
// llevar un registro o contador de impresion, etc.
string msg = "Impresión de factura No. " +
e.InvoiceInfo.Number.ToString() + "";
System.Console.WriteLine(msg);
}
}
}

// Por último la clase principal que muestra todo
// en funcionamiento
// Archivo InvoiceManagement.cs
namespace InvoiceManager
{
public class InvoiceManagement
{
// Punto de entrada de la aplicación
public static void Main(string[] args)
{
Invoice inv1 = new Invoice();
inv1.Number = 1;

Invoice inv2 = new Invoice();
inv2.Number = 2;

CashierSupervisor csup = new CashierSupervisor();
Cashier c1 = new Cashier();
Cashier c2 = new Cashier();

c1.PrintInvoice(csup.InvoPrinter, inv1);
c2.PrintInvoice(csup.InvoPrinter, inv2);
}
}
}

El código también funciona si se guarda en un solo
archivo con extensión cs... pero todas las clases bajo el
mismo namespace...

No existe ninguna regla para los nombres de los
delegados, eventos y clases que derivan de EventArgs,
solo seguí convenciones...
Los delegados tienen otros usos además de los eventos,
sería bueno que los revisaras...
En un caso práctico para este escenario, las clases
serían diferentes, pero para el ejemplo yo creo que
sirven... espero haber servido de algo...
Si no fui claro en algún punto o quieres discutir otras
cosas... con gusto a mi e-mail o por aqui mismo...

Saludos...

Donde puedo encontrar información que me hable de como
puedo manejar los eventos. Por ejemplo:
Si tengo un textbox en un form, antes en VB6 yo solo

daba

doble click sobre el objeto y luego seleccionaba el
evento que quería manejar, ahora hago doble click y solo
me aparece el evento click ¿y los otros como los
selecciono?. Ademas me salen dos parametros que no se

que

información traen.
.