java KeyEventHandler
Delegado público void EventHandler (remitente del objeto, EventArgs e)
Preste atención a los parámetros aquí. El primero es un objeto (de hecho, lo que se pasa aquí es una referencia de objeto. Si es un evento de clic del botón1, el remitente es el botón1), y el segundo es la clase base de la clase que contiene los datos del evento.
Estudiemos la clase Button y observemos la declaración del evento (usando la herramienta WinCV), tomando como ejemplo el evento Click.
Evento público EventHandler Click
Aquí se definen los eventos del tipo EventHandler Click.
El contenido anterior ha sido definido por C# en la biblioteca de clases. Veamos el código generado durante la programación.
Botón de anulación privada1_Click(Remitente del objeto, sistema. EventArgs e)
{
...
}
Este es nuestro método correspondiente al evento button1_click. Tenga en cuenta que los parámetros del método coinciden con la firma en el delegado (es decir, la lista de parámetros). Entonces, ¿cómo conectamos este método con el evento? Mire el código a continuación.
este.botón1. clic = nuevo sistema. EventHandler(this . button 1_Click);
Vincula el método this.button1_Click a this.button1. Haga clic en evento. Cadena 8
Estudiemos el flujo de trabajo del procesamiento de eventos de C#. Primero, el sistema creará un objeto para que escuchemos los eventos en segundo plano (si es un evento del botón1, es el botón1). Este objeto se utiliza para generar eventos. Si ocurre un evento de usuario, se generará el evento de aplicación correspondiente y luego se ejecutarán todos los métodos que se suscriban al evento.
En segundo lugar, un evento personalizado simple (1)
Primero, necesitamos definir una clase para escuchar los eventos del cliente, aquí escuchamos la entrada del teclado.
Definir delegación.
Delegado público void UserRequest(remitente del objeto, EventArgs e);
El primer objeto se utiliza para transmitir el generador del evento y el último EventArgs se utiliza para transmitir los detalles de el evento, que no está disponible por el momento. Úselo, se usará en ejemplos posteriores.
Los eventos de este tipo de delegado se definen a continuación.
Evento público UserRequest OnUserRequest
Hagamos un bucle infinito.
public void Run(){ bool terminado = false; do { if (console.ReadLine()== " h "){ OnUserRequest(this, new EventArgs() } } while(! Listo); );}
Este código sigue pidiendo al usuario que ingrese caracteres. Si el resultado de la entrada es H, se activará el evento OnUserRequest. El desencadenante del evento es él mismo (this) y los detalles del evento no están disponibles (no se pasa ninguna instancia de EventArgs para ningún parámetro). A esta clase la llamamos UserInputMonitor.
Lo que debemos hacer es definir la cadena de clase 5 del cliente.
Primero debes crear una instancia de la clase UserInputMonitor.
UserInputMonitor monitor = new UserInputMonitor();
Luego definimos un método.
ShowMessage anulado privado (remitente del objeto, EventArgs e)
{
Consola. WriteLine("Jaja!!");
}
Lo último que debemos hacer es asociar este método a un evento (suscríbete al evento), lo escribiremos en el cliente de biblioteca en el constructor de la clase.
Cliente (Monitor de entrada de usuario m)
{
medidor (abreviatura de medidor)) OnUserRequest = nuevo UserInputMonitor. UserRequest(this.show message);
//m . OnUserRequest = new m user request(this.show message);
//Tenga en cuenta que esta forma de escribir es incorrecta. , porque el delegado es estático.
}
Creemos una instancia de cliente.
Nuevo cliente (monitor);
Por cierto, no olvides dejar que el monitor comience a escuchar eventos.
monitor.run().
Ya terminaste. El código es el siguiente:
Utilice el monitor de entrada de usuario de clase del sistema {delegada pública solicitud de usuario nula (remitente de objeto, EventArgs e //Defina la solicitud de usuario de evento público delegado enuserrequest//El evento de este tipo de delegado public void run(){ bool terminado = false; do { if(console.ReadLine()== " h "){ OnUserRequest(this, new EventArgs() } } while(! Terminado }});
cliente de clase pública { public static void Main(){ monitor de entrada del usuario = nuevo monitor de entrada del usuario(); run();} private void ShowMessage(Remitente del objeto, EventArgs e) { Console. WriteLine("¡Jaja!!");} Client(UserInputMonitor m){ m. OnUserRequest = nuevo UserInputMonitor. UserRequest(this.show message); //m . OnUserRequest = new m . user request(this. show message); //Tenga en cuenta que esta forma de escribir es incorrecta porque el delegado es estático}} String 3
En tercer lugar, estudie más a fondo el mecanismo de manejo de eventos predefinido en C#
Tal vez descubra que algunos eventos en C# se ven diferentes a los anteriores. Por ejemplo
cuadro de texto vacío privado 1 _ KeyPress(remitente del objeto, sistema. windows . formularios . keypress eventargs e)
{
}
este.textBox1. clave=nuevo sistema.
windows .forms . KeyPress eventhandler(this . textbox 1 _ KeyPress);
Aquí se utiliza KeyPressEventArgs como parámetro, no EventArgs. Aquí se utiliza el delegado KeyEventHandler, no el delegado EventHandler.
KeyPressEventArgs es un derivado de EventArgs. La declaración de KeyEventHandler es la siguiente
Delegado público void KeyEventHandler (remitente del objeto, clave eventargs e); el parámetro KeyEventArgs Delegado. Entonces, ¿por qué suceden eventos clave como éste? Podemos encontrar la respuesta en los constructores de ambas clases.
Public EventArgs();
public keypress eventargs(char key char);
¿Cuáles son los datos clave aquí? Se utiliza para comunicar qué tecla presionamos, ja.
Encontré otra propiedad en KeyEventArgs.
public char KeyChar { get}
Esto prueba aún más mi teoría. Pongamos un ejemplo similar para ayudar a comprender.
4. Evento personalizado simple (2)
Utiliza el ejemplo que hicimos arriba para cambiarlo.
También definimos un EventArgs llamado MyEventArgs (similar a KeyEventArgs), definimos un constructor llamado public MyEventArgs(char keyChar) y también configuramos las propiedades correspondientes. El código es el siguiente: Cadena 3
Usar sistema; clase public MyMyEventArgs(char key char){ this . key char = key char;} public char key char { get { return key char;} }}
Debido a que ahora tenemos que escuchar varias claves, tenemos que anular do... para que también sea parte del oyente. Anule el delegado y reescriba los parámetros pasados por el cliente. Bien, el código final es el siguiente, muy agotador.
Usar sistema; clase public my eventargs(char key char){ this . key char = key char;} public char key char { get { return key char;} }}
class UserInputMonitor { solicitud de usuario nulo delegado público (remitente del objeto, mis eventargs e); // Definir la solicitud de usuario del evento público delegado en solicitud de usuario // Eventos de este tipo de delegado public void run(){ bool terminado = false; Consola.
ReadLine(); if (inputString!="") OnUserRequest(this, new my eventargs(input string[0]));} while(!finished);}}
public class Client { public static void Main(){ monitor de entrada del usuario = nuevo monitor de entrada del usuario(); nuevo cliente(monitor); run();} privado void show mensaje(objeto remitente, mis eventargs e) {console. writeline ("capturado: {0}", e . key char } Cliente (UserInputMonitor m) { m . UserRequest(this.show message); //m . OnUserRequest = new m . user request(this. show message); //Tenga en cuenta que esta forma de escribir es incorrecta porque el delegado es estático}}