[Explicación detallada de C#] Capítulo 5: Programación avanzada orientada a objetos: delegación y eventos

News 2023-08-26 00:37:04 views: null

Los delegados y eventos son conceptos importantes en la programación avanzada orientada a objetos, que se utilizan para lograr flexibilidad, escalabilidad y mantenibilidad del programa. Desempeñan un papel clave en la implementación de devoluciones de llamadas, manejo de eventos y programación asincrónica, entre otras cosas.
Los delegados nos permiten tratar un método como un objeto que puede pasarse como parámetro, almacenarse en una variable y llamarse cuando sea necesario. Esta capacidad hace que los delegados sean ideales para implementar funciones de devolución de llamada, pasando un método a otro para que este último llame al primero cuando sea apropiado. La delegación también admite el concepto de cadena de delegación y delegación de multidifusión. Se pueden vincular varios métodos para formar una cadena de delegación y se ejecutan en secuencia.
Los eventos son una forma especial de delegación que se utiliza para implementar el patrón Observer y la programación basada en eventos. Los eventos proporcionan una manera concisa y confiable de manejar y responder a eventos específicos del programa, como la interacción del usuario, la notificación de mensajes, etc. A través del evento podemos definir el editor y suscriptor del evento, cuando el editor activa el evento, el suscriptor recibirá la notificación y realizará la operación correspondiente. Este patrón de diseño débilmente acoplado hace que el programa sea más escalable y mantenible.
Los delegados y eventos también juegan un papel importante en la programación asincrónica. Pueden ayudarnos a manejar devoluciones de llamadas y notificaciones para operaciones asincrónicas, mejorando la capacidad de respuesta y la eficiencia de los programas. Al encapsular operaciones asincrónicas en delegados o eventos, podemos ejecutar la lógica de procesamiento correspondiente una vez completadas las operaciones asincrónicas sin bloquear el subproceso principal ni realizar una gestión de subprocesos compleja.

1. El concepto y uso básico de la encomienda

1.1 Definición y características de la encomienda

Un delegado es un tipo de referencia en C# que nos permite tratar métodos como objetos y pasar métodos como parámetros, almacenarlos en variables y llamarlos cuando sea necesario.
La definición de delegado incluye dos partes principales: la declaración del tipo de delegado y la creación de la instancia del delegado. Una declaración de tipo de delegado especifica la firma del método, incluidos los tipos de parámetros y el tipo de retorno. Una instancia delegada es un objeto creado según el tipo de delegado, que puede hacer referencia a uno o más métodos. Las principales características de la delegación son las siguientes:

  1. Los delegados tienen seguridad de tipos: el tipo de delegado define la firma del método y solo se pueden asignar métodos con la misma firma a instancias del tipo de delegado.
  2. La delegación es componible: se pueden combinar varios métodos a través de cadenas de delegación para formar una cadena de delegación. Cada método de la cadena de delegación se puede llamar por turno.
  3. Los delegados son mutables: los métodos se pueden agregar o eliminar dinámicamente desde la instancia del delegado. Los métodos se pueden agregar usando el operador "+" y eliminar usando el operador "-".
  4. El delegado es la base de la programación asincrónica: el delegado se puede utilizar para manejar la función de devolución de llamada de la operación asincrónica, y el procesamiento correspondiente se realiza llamando a la instancia del delegado una vez completada la operación asincrónica.

Los delegados desempeñan un papel importante en la implementación de devoluciones de llamadas, procesamiento de eventos y programación multiproceso. Proporcionan una forma flexible, extensible y fácil de mantener para manejar la invocación y comunicación de métodos, lo que hace que la programación sea más flexible y extensible.

1.2 Sintaxis y declaración de delegado

La sintaxis y declaración del delegado incluyen principalmente los siguientes pasos:

  1. Definición del tipo de delegado: utilice delegatela palabra clave para definir el tipo de delegado. El tipo de delegado define la firma del método, incluidos los tipos de parámetros y el tipo de retorno. El formato de sintaxis es el siguiente:

    delegate <返回类型> <委托类型名>(<参数列表>);

    Por ejemplo, defina un tipo de delegado que tome dos parámetros enteros y devuelva un número entero:

    delegate int MyDelegate(int x, int y);

  2. Cree una instancia de delegado: cree una instancia de delegado según el tipo de delegado y asigne el método a la instancia de delegado. Las instancias delegadas se pueden crear utilizando métodos anónimos, expresiones lambda o métodos con nombre. El formato de sintaxis es el siguiente:

    <委托类型> <委托实例名> = new <委托类型>(<方法名>);

    Por ejemplo, cree una instancia delegada y asígnela a un método con nombre:

    MyDelegate myDelegate = new MyDelegate(MyMethod);

  3. Llamar a la instancia delegada: use la instancia delegada para llamar al método. Se puede invocar utilizando la instancia delegada como un método normal.

    int result = myDelegate(10, 20);

    Al llamar a una instancia de delegado, el delegado llamará a estos métodos en el orden de los métodos asociados y devolverá el resultado del último método (si hay un valor de retorno).

Precauciones:

  • La lista de parámetros y el tipo de retorno de un tipo de delegado deben coincidir con la firma del método asociado.
  • Una instancia delegada solo puede llamar a métodos que coincidan con el tipo de delegado. Se producirá un error de compilación si la instancia delegada invoca un método que no coincide.
  • Un tipo de delegado es un tipo de referencia y se puede pasar una referencia a un método a través de la instancia de delegado en lugar de llamar al método directamente.
  • Los métodos se pueden agregar y eliminar usando los operadores +=y . El operador agrega un método a la cadena de delegación y el operador elimina un método de la cadena de delegación.-=+=-=
1.3 Delegar creación de instancias e invocación

La creación de instancias e invocación del delegado implica principalmente los siguientes pasos:

  1. Cree una instancia de delegado: cree una instancia de delegado según el tipo de delegado y asóciela con uno o más métodos. Las instancias delegadas se pueden crear utilizando métodos anónimos, expresiones lambda o métodos con nombre.

    <委托类型> <委托实例名> = new <委托类型>(<方法名>);

    Por ejemplo, cree una instancia delegada y asóciela con un método con nombre:

    MyDelegate myDelegate = new MyDelegate(MyMethod);

  2. Llamar a la instancia delegada: invocar el método asociado a través de la instancia delegada. Se puede llamar a una instancia delegada como un método normal, pasando parámetros y obteniendo un valor de retorno.

    <返回值类型> result = <委托实例名>(<参数列表>);

    Por ejemplo, usar una instancia delegada para llamar a un método asociado:

    int result = myDelegate(10, 20);

    Tenga en cuenta que la invocación de la instancia delegada procederá en el orden de los métodos en la cadena de delegados, llamando a cada método por turno y devolviendo el valor de retorno del último método (si lo hay).

1.4 Cadena de delegación y delegación de multidifusión

Una cadena de delegación es un mecanismo para combinar múltiples instancias de delegación en una cadena lógica. Una cadena de delegación se puede crear combinando una instancia de delegación con otra instancia de delegación.
Un delegado de multidifusión es un tipo especial de delegado que puede contener múltiples instancias de delegado, que se invocan secuencialmente en el orden en que se agregan. Al utilizar la delegación de multidifusión, se pueden agregar o eliminar instancias delegadas de la cadena de delegados, extendiendo o modificando dinámicamente el comportamiento de la cadena de delegados. En C#, puede usar +el operador para combinar varias instancias de delegado en una cadena de delegados y usar -el operador para eliminar la instancia de delegado de la cadena de delegados.
Aquí hay un código de muestra usando el delegado de multidifusión:

public delegate void MyDelegate();

static void Main()
{
    
    
    MyDelegate myDelegate1 = Method1;
    MyDelegate myDelegate2 = Method2;

    // 创建委托链
    MyDelegate myDelegateChain = myDelegate1 + myDelegate2;

    // 调用委托链中的方法
    myDelegateChain();

    // 从委托链中移除委托实例
    myDelegateChain -= myDelegate2;

    // 再次调用委托链中的方法
    myDelegateChain();
}

static void Method1()
{
    
    
    Console.WriteLine("Method 1");
}

static void Method2()
{
    
    
    Console.WriteLine("Method 2");
}

Resultado de salida:

Method 1
Method 2
Method 1

En el ejemplo anterior, myDelegate1y myDelegate2son dos instancias de delegado separadas. Al usar +el operador para combinarlos en una cadena de delegación myDelegateChain, y luego, cuando se llama a la cadena de delegación, los métodos de las dos instancias delegadas se llamarán por turno. Luego, use -el operador para myDelegate2eliminar de la cadena de delegación, y cuando vuelva a llamar a la cadena de delegación, solo myDelegate1se llamará al método de.
Los delegados de multidifusión proporcionan una manera conveniente y flexible de manejar múltiples instancias de delegados y ejecutar sus métodos en un orden específico. Es muy útil en escenarios como manejo de eventos, mecanismo de devolución de llamada, etc.

2. Escenarios de aplicación encargados

2.1 Función de devolución de llamada

Un escenario de aplicación común de delegación es la función de devolución de llamada (Devolución de llamada). La función de devolución de llamada significa que cuando se completa una operación o ocurre un evento, el sistema llama a una función preregistrada para procesar la lógica correspondiente. A través del mecanismo de delegación, una función puede pasarse como parámetro a otra función, de modo que esta última pueda llamar a la función entrante en el momento adecuado. Este mecanismo es útil en situaciones donde se requieren operaciones asincrónicas, manejo de eventos, interacción del usuario, etc. El siguiente es un código de muestra que implementa una función de devolución de llamada utilizando delegados:

public delegate void CallbackFunction(string message);

public class Operation
{
    
    
    public void LongRunningOperation(CallbackFunction callback)
    {
    
    
        // 模拟耗时操作
        Console.WriteLine("开始执行长时间操作...");
        Thread.Sleep(2000);
        Console.WriteLine("长时间操作完成。");

        // 调用回调函数
        callback("操作已完成");
    }
}

public class Program
{
    
    
    static void Main()
    {
    
    
        Operation operation = new Operation();
        operation.LongRunningOperation(OnOperationComplete);
    }

    static void OnOperationComplete(string message)
    {
    
    
        Console.WriteLine("操作回调：" + message);
    }
}

Resultado de salida:

开始执行长时间操作...
长时间操作完成。
操作回调：操作已完成

En el ejemplo anterior, el método Operationde la clase LongRunningOperationrealiza una operación que requiere mucho tiempo y luego CallbackFunctionllama a la función de devolución de llamada a través del parámetro de tipo delegado pasado. ProgramEl método de la clase OnOperationCompleteactúa como una función de devolución de llamada que se llama y genera un mensaje cuando se completa la operación.
Al utilizar delegados y funciones de devolución de llamada, se puede notificar a la persona que llama sobre el resultado o el estado de la operación, y la lógica correspondiente se puede ejecutar en el momento apropiado, logrando un control e interacción más flexibles del programa. Las funciones de devolución de llamada se utilizan a menudo en escenarios como programación asincrónica, programación basada en eventos e interacción de interfaz de usuario.

2.2 Procesamiento de eventos

Los delegados se utilizan ampliamente en el manejo de eventos. Un evento se refiere a una acción específica o un cambio de estado que ocurre en un programa, y ​​el procesamiento de eventos es un mecanismo para responder y procesar estos eventos. Mediante la combinación de delegación y eventos, se puede implementar un patrón de diseño débilmente acoplado, es decir, programación basada en eventos. En la programación basada en eventos, los objetos se comunican definiendo eventos y delegados correspondientes. Cuando ocurre un evento, se llamará al método registrado con el delegado correspondiente para responder al evento. El siguiente es un código de muestra para el manejo de eventos utilizando delegados y eventos:

public class Button
{
    
    
    public event EventHandler Click;

    public void OnClick()
    {
    
    
        // 触发 Click 事件
        Click?.Invoke(this, EventArgs.Empty);
    }
}

public class Program
{
    
    
    static void Main()
    {
    
    
        Button button = new Button();
        button.Click += Button_Click;

        button.OnClick();
    }

    static void Button_Click(object sender, EventArgs e)
    {
    
    
        Console.WriteLine("按钮被点击了！");
    }
}

Resultado de salida:

按钮被点击了！

En el ejemplo anterior, Buttonla clase define un Clickevento denominado y utiliza EventHandlerel delegado como tipo de controlador de eventos. ButtonEl método de la clase OnClickse utiliza para activar Clickel evento y Click?.Invoke(this, EventArgs.Empty)llamar al controlador de eventos registrado a través de . En Programla clase, creamos una instancia de un Buttonobjeto y registramos el método como controlador de eventos +=a través del operador . Luego, el evento de clic del botón se activa llamando y se ejecuta el método de controlador de eventos correspondiente. Al utilizar delegados y eventos, podemos desacoplar fácilmente los eventos del procesamiento de eventos, haciendo que la interacción de los objetos sea más flexible y extensible. Los patrones de programación basados ​​en eventos se utilizan ampliamente en la interfaz gráfica de usuario (GUI), la interacción del usuario, la programación asincrónica y otros escenarios.Button_ClickClickbutton.OnClick()

2.3 Programación asincrónica

Delegado juega un papel importante en la programación asincrónica, puede ayudar a manejar operaciones que requieren mucho tiempo y mejorar el rendimiento y la capacidad de respuesta de las aplicaciones. En el modelo de programación síncrona tradicional, cuando un programa realiza una operación que requiere mucho tiempo, bloquea el hilo principal y hace que la aplicación deje de responder. El modelo de programación asincrónica implementa operaciones asincrónicas mediante el uso de delegados, de modo que el hilo principal pueda continuar realizando otras tareas sin esperar a que se completen operaciones que consumen mucho tiempo. El siguiente es un código de muestra para programación asincrónica usando delegados:

public class Worker
{
    
    
    public delegate void WorkCompletedHandler(string result);

    public void DoWorkAsync(WorkCompletedHandler callback)
    {
    
    
        // 模拟耗时操作
        Console.WriteLine("开始执行异步操作...");
        Thread.Sleep(2000);
        string result = "操作已完成";

        // 异步操作完成后调用回调函数
        callback(result);
    }
}

public class Program
{
    
    
    static void Main()
    {
    
    
        Worker worker = new Worker();
        worker.DoWorkAsync(OnWorkCompleted);

        Console.WriteLine("主线程继续执行其他任务...");
        // 等待异步操作完成
        Console.ReadLine();
    }

    static void OnWorkCompleted(string result)
    {
    
    
        Console.WriteLine("异步操作回调：" + result);
    }
}

Resultado de salida:

开始执行异步操作...
主线程继续执行其他任务...
异步操作回调：操作已完成

En el ejemplo anterior, el método Workerde la clase DoWorkAsyncsimula una operación asincrónica que requiere mucho tiempo y WorkCompletedHandlerllama a la función de devolución de llamada después de que se completa la operación a través del parámetro de tipo delegado entrante. En Programla clase, creamos una instancia de un Workerobjeto y llamamos DoWorkAsyncal método, pasando OnWorkCompletedel método como una función de devolución de llamada. En el hilo principal, podemos continuar realizando otras tareas sin esperar a que se complete la operación asincrónica.
La programación asincrónica puede mejorar el rendimiento y la capacidad de respuesta de las aplicaciones a través del mecanismo de delegación y funciones de devolución de llamada. Se usa ampliamente en escenarios que necesitan realizar operaciones que requieren mucho tiempo, evitar el bloqueo del hilo principal y el procesamiento concurrente.

3. El concepto y uso básico de los eventos.

3.1 Definición y características de los eventos

Los eventos son un mecanismo en la programación orientada a objetos para manejar acciones específicas o cambios de estado que ocurren en los objetos. Los eventos pueden considerarse como un tipo especial de delegado que proporciona una forma poco acoplada para que los objetos se comuniquen definiendo y desencadenando eventos.
Los eventos tienen las siguientes características:

  1. Modelo de editor y suscriptor: los eventos suelen tener un objeto como editor que activa el evento cuando se cumplen ciertas condiciones. Otros objetos pueden suscribirse al evento y proporcionar la lógica de procesamiento correspondiente para responder a la ocurrencia del evento.
  2. Delegados como tipos de controladores de eventos: los eventos suelen utilizar tipos de delegados para definir controladores de eventos. Un delegado es un tipo utilizado para hacer referencia a un método, que puede pasarse como parámetro e invocarse cuando ocurre un evento.
  3. Registro y baja de controladores de eventos: los objetos que se suscriben a eventos pueden utilizar +=el operador para registrar sus propios métodos como controladores de eventos. Cuando ocurre un evento, se llamará al controlador de eventos registrado. Al utilizar -=el operador, se puede cancelar el registro de un controlador de eventos para dejar de recibir notificaciones de eventos.
  4. Compatibilidad con múltiples controladores de eventos: los eventos pueden admitir múltiples controladores de eventos, es decir, varios métodos pueden suscribirse al mismo evento al mismo tiempo. Cuando ocurre un evento, se llamará a todos los controladores de eventos suscritos.
  5. Diseño débilmente acoplado: el mecanismo de eventos realiza un acoplamiento flexible entre objetos, y el objeto editor no necesita comprender ni depender directamente de la implementación específica del objeto suscriptor. Los editores solo necesitan activar eventos y los suscriptores deciden cómo manejarlos.
3.2 Sintaxis y declaración de eventos

En C#, la sintaxis para declarar y usar eventos es la siguiente:

  1. Definir eventos:
    public event EventHandler MyEvent;
    El código anterior define un MyEventevento denominado de tipo EventHandler. EventHandlerEs un tipo de delegado predefinido, normalmente utilizado para manejar eventos sin parámetros.
  2. Declarar controladores de eventos:
    private void OnMyEvent(object sender, EventArgs e)
{
    // 处理事件的逻辑代码
}
    El código anterior declara un OnMyEventmétodo de controlador de eventos llamado , que acepta dos parámetros: senderel objeto publicador que representa el evento ey los parámetros del evento. Según las necesidades reales, puede personalizar el nombre y los parámetros del método del controlador de eventos.
  3. Registrar controladores de eventos:
    MyEvent += OnMyEvent;
    El código anterior OnMyEventregistra el método como MyEventcontrolador del evento. El método será llamado cuando MyEventse active el evento .OnMyEvent
  4. Anular el registro de controladores de eventos:
    MyEvent -= OnMyEvent;
    El código anterior cancela el registro OnMyEventdel método de MyEventla lista de controladores del evento y deja de recibir notificaciones de eventos.

Tenga en cuenta que el código anterior es solo un ejemplo, puede ajustarlo y expandirlo de acuerdo con sus necesidades y escenarios reales. Al mismo tiempo, también puede definir tipos de parámetros de eventos personalizados según sea necesario para transportar más información para que la utilice el procesador de eventos.

3.3 Suscripción y activación de eventos

En C#, el proceso de suscripción y activación de eventos es el siguiente:

  1. Definir eventos:

    public event EventHandler MyEvent;

    Defina un MyEventevento denominado , utilizando EventHandlerel tipo de delegado como tipo de evento.

  2. Definir controladores de eventos:

    private void OnMyEvent(object sender, EventArgs e)
{
    // 处理事件的逻辑代码
}

    Defina un OnMyEventmétodo denominado controlador de eventos, que acepte dos parámetros: senderel objeto publicador que representa el evento ey el parámetro del evento.

  3. Suscríbete a eventos:

    MyEvent += OnMyEvent;

    El método del controlador de eventos se suscribe al evento mediante +=el operador . De esta manera, cuando se active el evento, se llamará al método del controlador de eventos.OnMyEventMyEventMyEvent

  4. acontecimiento desencadenante:

    MyEvent?.Invoke(this, EventArgs.Empty);

    ?.InvokeLos eventos se activan utilizando la sintaxis MyEvent. Esto, a su vez, llama a todos los métodos del controlador de eventos suscritos al evento. Parámetro thisIndica el objeto publicador del evento e EventArgs.Emptyindica los parámetros del evento. Aquí se utiliza un objeto de parámetro vacío.

  5. Darse de baja de eventos:

    MyEvent -= OnMyEvent;

    Utilice -=el operador para cancelar la suscripción de un método de controlador de eventos OnMyEventde la lista de suscripción del evento . MyEventDe esta manera, cuando MyEventse active el evento, ya no se llamará al método del controlador de eventos.

Los anteriores son los pasos básicos para suscribirse y activar eventos, que puede ajustar y ampliar según las necesidades y escenarios reales. Tenga en cuenta que la suscripción y la activación de eventos deben realizarse en el momento adecuado para garantizar el proceso de manejo de eventos correcto.

4. Escenarios de aplicación de eventos

4.1 Interacción del usuario en aplicaciones GUI

En las aplicaciones GUI (interfaz gráfica de usuario), los eventos juegan un papel importante en el manejo de las interacciones del usuario. Los siguientes son algunos escenarios de aplicación comunes de eventos en aplicaciones GUI:

  1. Evento de clic de botón: un evento que se activa cuando el usuario hace clic en un botón en la interfaz y se pueden realizar operaciones relacionadas en el controlador de eventos, como enviar un formulario, abrir una nueva ventana, etc.
  2. Evento de entrada del cuadro de texto: un evento que se activa cuando el usuario ingresa contenido en el cuadro de texto. El texto de entrada se puede obtener a través del controlador de eventos y procesar en consecuencia, como verificación de entrada, búsqueda en tiempo real, etc.
  3. Evento de selección de menú: un evento que se activa cuando el usuario selecciona una opción en el menú y las operaciones correspondientes se pueden realizar en el controlador de eventos, como abrir una página de función específica, ejecutar un comando específico, etc.
  4. Movimiento del mouse y eventos de clic: los eventos que se activan cuando el usuario mueve el mouse en la interfaz o hace clic en un elemento específico pueden responder a las operaciones del mouse de acuerdo con la lógica del controlador de eventos, como mostrar información de solicitud, arrastrar elementos, etc.
  5. Evento de cierre de ventana: el evento que se activa cuando el usuario cierra la ventana, puede realizar operaciones relacionadas en el controlador de eventos, como guardar datos, limpiar recursos, etc.

Mediante el uso de eventos, las aplicaciones GUI pueden lograr interacción y respuesta con los usuarios, proporcionando una experiencia de usuario más amigable y flexible. Los desarrolladores pueden implementar diversas lógicas y funciones de interacción del usuario suscribiéndose y procesando los eventos correspondientes.

4.2 Notificación de mensajes y basada en eventos

Los eventos tienen una amplia gama de escenarios de aplicación en notificación de mensajes y programación basada en eventos. Los siguientes son casos de uso comunes para eventos en estas áreas:

  1. Notificación de mensajes: los eventos se pueden utilizar para implementar un mecanismo de notificación de mensajes. Cuando ocurre un evento, el sistema puede activar el evento correspondiente y notificar a otros módulos u objetos que se hayan suscrito al evento. Esto puede lograr el desacoplamiento y la entrega de mensajes entre módulos.
  2. Patrón de publicación-suscripción: los eventos se pueden utilizar para implementar un patrón de publicación-suscripción, donde un objeto (editor) desencadena un evento y otros objetos (suscriptores) se suscriben al evento y responden a la lógica de procesamiento correspondiente. Este patrón es muy común en escenarios como sistemas distribuidos y colas de mensajes.
  3. Interacción del usuario en aplicaciones GUI: en las aplicaciones de interfaz gráfica de usuario (GUI), la programación basada en eventos es un patrón común. Cuando el usuario interactúa con la interfaz, los eventos se utilizan para desencadenar las operaciones de respuesta correspondientes. Por ejemplo, hacer clic en un botón, arrastrar un elemento, ingresar el teclado, etc. puede desencadenar los eventos correspondientes para su procesamiento.
  4. Programación asincrónica: los eventos se pueden utilizar para implementar un modelo de programación asincrónica, en el que se activa un evento cuando se completa una operación para notificar a otras partes que la procesen. Esto resulta útil cuando se trata de grandes cantidades de datos, tareas de larga duración o cuando se requiere interacción con recursos externos.
  5. Extensión de marcos y bibliotecas: al definir y utilizar eventos, los desarrolladores pueden proporcionar puntos de extensión para marcos y bibliotecas, lo que permite a otros desarrolladores registrar lógica personalizada en eventos específicos, logrando así extensiones de funciones personalizadas y flexibles.

Mediante el uso de eventos, se puede lograr un acoplamiento flexible entre módulos, escalabilidad flexible y gestión de operaciones asincrónicas. Es un mecanismo poderoso que permite que varias partes de un programa trabajen juntas de manera eficiente e interactúen de una manera que responda a los eventos.

5. Comparación y selección de delegados y eventos.

5.1 La diferencia entre delegado y evento

Los delegados y eventos son dos conceptos importantes en la programación orientada a objetos, que se utilizan para implementar el paso y procesamiento de mensajes entre objetos. Si bien son similares en algunos aspectos, existen algunas diferencias en sus definiciones, usos y propósitos.

  1. Definición y sintaxis:
    • Un delegado es un tipo que encapsula una referencia a un método. Define la firma del método y el tipo de retorno, y puede usarse para declarar variables, parámetros y tipos de retorno.
    • Los eventos son un tipo especial de delegado que se utiliza para definir y desencadenar acciones específicas. Los eventos se eventdeclaran utilizando la palabra clave y solo se pueden definir en clases o estructuras.
  2. Función y propósito:
    • Los delegados se utilizan para pasar referencias a métodos, lo que permite pasar métodos como parámetros a otros métodos o almacenarlos en variables. Los delegados se utilizan a menudo en escenarios como funciones de devolución de llamada, procesamiento de eventos y programación asincrónica.
    • Los eventos son un tipo especial de delegado que se utiliza para definir y desencadenar acciones o notificaciones específicas. Permite que una clase o estructura notifique a otros objetos cuando ocurre un evento específico y ejecute el controlador de eventos correspondiente.
  3. Suscríbete y activa:
    • Un delegado puede +=suscribirse a varios métodos utilizando el operador, de modo que varios métodos puedan responder a la llamada del delegado. Cuando se invoca al delegado, los métodos suscritos se invocarán en secuencia.
    • Un evento es una forma especial de delegación, que solo puede activarse dentro de la clase, y los objetos externos solo pueden responder a la ocurrencia de eventos suscribiéndose al evento.
  4. Seguridad y encapsulación:
    • Los eventos tienen mayor seguridad y encapsulación, porque los eventos solo se pueden activar dentro de la clase y los objetos externos no pueden llamar ni cambiar directamente la activación de eventos.
    • Un delegado es relativamente más flexible en su uso porque puede almacenarse en una variable y permite que objetos externos llamen al delegado directamente.
5.2 Seleccionar el delegado y evento apropiado

Al elegir delegados y eventos adecuados, se deben considerar escenarios de aplicación y requisitos específicos. Aquí hay algunas sugerencias:

  1. oficial:
    • Utilice delegados para pasar referencias de métodos para cumplir con requisitos como funciones de devolución de llamada o programación asincrónica.
    • Si necesita pasar métodos entre diferentes objetos y desea que estos objetos puedan realizar llamadas a métodos de forma independiente, puede optar por utilizar la delegación.
  2. evento:
    • Utilice eventos para definir y desencadenar acciones o notificaciones específicas para lograr el desacoplamiento y el paso de mensajes entre objetos.
    • Si necesita desencadenar una acción específica dentro de la clase y desea que otros objetos se suscriban y respondan a esta acción, puede optar por utilizar eventos.
  3. Considere la seguridad y la encapsulación:
    • Si desea limitar la activación y operación de eventos por objetos externos y proteger el estado interno de la clase, puede optar por utilizar eventos.
    • Si necesita pasar de manera flexible la referencia del método y desea que el objeto externo llame al delegado directamente, puede optar por utilizar el delegado.
  4. Considere la escalabilidad y la reutilización:
    • Puede optar por utilizar eventos cuando desee poder compartir la misma definición de evento entre varias clases y que cada clase pueda agregar y responder a controladores de eventos de forma independiente.
    • Si desea poder reutilizar el mismo tipo de delegado en varios lugares y no limitarse a eventos internos de una clase específica, puede optar por utilizar delegados.

En resumen, los delegados son adecuados para escenarios como pasar referencias de métodos, implementar funciones de devolución de llamada y programación asincrónica, mientras que los eventos son adecuados para definir y desencadenar acciones o notificaciones específicas y lograr el desacoplamiento entre objetos. Según los requisitos de la aplicación, elija el mecanismo más adecuado para realizar la función y cumplir con los requisitos.

6. Mejores prácticas y precauciones para la puesta en servicio y eventos

A continuación se muestran algunas prácticas recomendadas y consideraciones al utilizar delegados y eventos:

  1. Denominación de delegados y eventos: la denominación debe reflejar con precisión su propósito y función, y seguir las convenciones de nomenclatura para mejorar la legibilidad del código.
  2. Gestión delegada del ciclo de vida: cuando utilice delegados, debe asegurarse de que el ciclo de vida delegado se gestione correctamente para evitar posibles pérdidas de memoria. Utilice los métodos adecuados para agregar y eliminar suscripciones delegadas.
  3. Calendario de activación de eventos: al diseñar e implementar eventos, debe considerar el momento de activación de los eventos para garantizar que se activen en el momento adecuado para cumplir con los requisitos y funciones.
  4. Seguridad de los controladores de eventos: cuando otros objetos se suscriben y responden a eventos, se debe garantizar la seguridad de los controladores de eventos para manejar posibles excepciones y condiciones de error para garantizar la estabilidad del programa.
  5. Documentación de delegados y eventos: proporcione documentación clara en el código para explicar el propósito, el uso y el comportamiento esperado de los delegados y eventos para ayudar a otros desarrolladores a comprenderlos y utilizarlos.
  6. Aplicabilidad de delegados y eventos: al elegir utilizar delegados y eventos, se deben considerar necesidades y escenarios específicos para garantizar su aplicabilidad y racionalidad. No abuse de los delegados y eventos, elija el mecanismo de programación adecuado según la situación real.
  7. Claridad y mantenibilidad del código: cuando utilice delegados y eventos, mantenga la claridad y la mantenibilidad del código, y siga un buen estilo de codificación y principios de diseño para mejorar la legibilidad y la mantenibilidad del código.

7. Resumen

Los delegados y eventos son conceptos importantes en la programación orientada a objetos, brindan flexibilidad y extensibilidad, lo que nos permite lograr código desacoplado y reutilizable. Los delegados nos permiten pasar y almacenar métodos como parámetros y llamarlos cuando sea necesario, lo cual es muy útil para implementar funciones de devolución de llamada y programación asincrónica. Los eventos son una forma especial de delegación que maneja acciones específicas o desencadena condiciones específicas. Los eventos proporcionan una forma poco acoplada de notificar y responder a interacciones entre objetos.
Al utilizar delegados y eventos, debemos seguir las mejores prácticas y consideraciones, como nombres precisos, gestión correcta del ciclo de vida, activación oportuna de eventos, manejo de seguridad y excepciones, proporcionar documentación clara, etc. La elección del delegado y el evento adecuados depende de las necesidades y escenarios específicos y garantiza su aplicabilidad y racionalidad. Es muy importante mantener el código claro y fácil de mantener. Un buen estilo de codificación y principios de diseño pueden mejorar la legibilidad y el mantenimiento del código.

Supongo que te gusta

Origin blog.csdn.net/gangzhucoll/article/details/131750446
Recomendado
Clasificación
Diario
Más
2024-05-29(1)
2024-05-28(0)
2024-05-27(1)
2024-05-26(1)
2024-05-25(0)
2024-05-24(13)
2024-05-23(34)
2024-05-22(10)
2024-05-21(34)
2024-05-20(5)

Code World

© 2018 codetd.com