AYUDA .NET

C# Delegates (Cómo funciona para los desarrolladores)

En la programación en C#, la comprensión de los delegados es de suma importancia para escribir código flexible y extensible. Los delegados sirven como poderosas entidades que facilitan la implementación de callbacks, manejo de eventos y paradigmas de programación funcional dentro del lenguaje. La guía de Microsoft sobre delegados proporciona una visión general completa sobre las instancias de Delegados para ser utilizadas en aplicaciones de C#.

En esta completa guía, profundizaremos en las complejidades de los delegados de C#, explorando su funcionalidad, casos de uso y cómo permiten a los desarrolladores escribir código más modular y escalable.

Entendiendo C# Delegados: La columna vertebral de las devoluciones de llamada

En esencia, un delegado en C# es un objeto de tipo seguro también conocido como puntero de función que encapsula un método o más de un método. Los delegados permiten la creación de referencias a funciones, proporcionando un medio para pasar métodos como parámetros, almacenarlos en estructuras de datos e invocarlos dinámicamente. Esto convierte a los delegados en la piedra angular para conseguir mecanismos de devolución de llamada e implementar arquitecturas basadas en eventos.

Características principales de C# Delegados

  1. Seguridad de tipos: Los delegados son seguros en cuanto a tipos, lo que garantiza que la firma del método que referencian coincida con la firma del delegado.

  2. Multicast: Los delegados admiten la invocación multicast, lo que permite combinar varios métodos en una única instancia de delegado. Cuando se invocan, todos los métodos del delegado de multidifusión se llaman secuencialmente.

  3. Métodos Anónimos y Expresiones Lambda: Los delegados de C# se integran perfectamente con métodos anónimos y expresiones lambda, proporcionando una sintaxis concisa para definir cuerpos de métodos en línea.

Uso básico y sintaxis

Los pasos fundamentales para utilizar delegados implican la declaración con el tipo de delegado y los parámetros, la instanciación y la invocación mediante la definición de métodos de devolución de llamada. He aquí un ejemplo básico:

// Delegate declaration
public delegate void MyDelegate(string message);
// Instantiation
MyDelegate myDelegate = DisplayMessage;
// Method to be referenced
static void DisplayMessage(string message)
{
    Console.WriteLine(message);
}
// Invocation
myDelegate("Hello, Delegates!");
// Delegate declaration
public delegate void MyDelegate(string message);
// Instantiation
MyDelegate myDelegate = DisplayMessage;
// Method to be referenced
static void DisplayMessage(string message)
{
    Console.WriteLine(message);
}
// Invocation
myDelegate("Hello, Delegates!");
' Delegate declaration
Public Delegate Sub MyDelegate(ByVal message As String)
' Instantiation
Private myDelegate As MyDelegate = AddressOf DisplayMessage
' Method to be referenced
Shared Sub DisplayMessage(ByVal message As String)
	Console.WriteLine(message)
End Sub
' Invocation
myDelegate("Hello, Delegates!")
$vbLabelText   $csharpLabel

Escenarios de devolución de llamada: Aprovechar la flexibilidad de los delegados

Uno de los principales casos de uso de los delegados es la implementación de callbacks. Considere escenarios donde un método necesita notificar a un componente externo cuando ocurre un evento específico. Los delegados ofrecen una solución limpia y modular:

class Program
{
static void Main(string [] args)
{
   public class EventPublisher
   {
       // Declare a delegate
       public delegate void EventHandler(string eventName);
       // Create an instance of the delegate
       public EventHandler EventOccurred;
       // Simulate an event
       public void SimulateEvent(string eventName)
       {
           // Invoke the delegate to notify subscribers
           EventOccurred?.Invoke(eventName);
       }
   }
   public class EventSubscriber
   {
       public EventSubscriber(EventPublisher eventPublisher)
       {
           // Subscribe to the event using the delegate
           eventPublisher.EventOccurred += HandleEvent;
       }
       // Method to be invoked when the event occurs
       private void HandleEvent(string eventName)
       {
           Console.WriteLine($"Event handled: {eventName}");
       }
   }
}
}
class Program
{
static void Main(string [] args)
{
   public class EventPublisher
   {
       // Declare a delegate
       public delegate void EventHandler(string eventName);
       // Create an instance of the delegate
       public EventHandler EventOccurred;
       // Simulate an event
       public void SimulateEvent(string eventName)
       {
           // Invoke the delegate to notify subscribers
           EventOccurred?.Invoke(eventName);
       }
   }
   public class EventSubscriber
   {
       public EventSubscriber(EventPublisher eventPublisher)
       {
           // Subscribe to the event using the delegate
           eventPublisher.EventOccurred += HandleEvent;
       }
       // Method to be invoked when the event occurs
       private void HandleEvent(string eventName)
       {
           Console.WriteLine($"Event handled: {eventName}");
       }
   }
}
}
Friend Class Program
Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public class EventPublisher
'   {
'	   ' Declare a delegate
'	   public delegate void EventHandler(string eventName);
'	   ' Create an instance of the delegate
'	   public EventHandler EventOccurred;
'	   ' Simulate an event
'	   public void SimulateEvent(string eventName)
'	   {
'		   ' Invoke the delegate to notify subscribers
'		   if (EventOccurred != Nothing)
'			   EventOccurred.Invoke(eventName);
'	   }
'   }
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   public class EventSubscriber
'   {
'	   public EventSubscriber(EventPublisher eventPublisher)
'	   {
'		   ' Subscribe to the event using the delegate
'		   eventPublisher.EventOccurred += HandleEvent;
'	   }
'	   ' Method to be invoked when the event occurs
'	   private void HandleEvent(string eventName)
'	   {
'		   Console.WriteLine(string.Format("Event handled: {0}", eventName));
'	   }
'   }
End Sub
End Class
$vbLabelText   $csharpLabel

Programación funcional con delegados

Los delegados desempeñan un papel crucial en la adopción de conceptos de programación funcional en C#. Utilizando delegados con funciones de orden superior, los desarrolladores pueden pasar funciones como argumentos, devolver funciones y crear código más expresivo y conciso:

public delegate int MyDelegate(int x, int y);
public class Calculator
{
    public int PerformOperation(MyDelegate operation, int operand1, int operand2)
    {
        return operation(operand1, operand2);
    }
}
// Usage
var calculator = new Calculator();
int result = calculator.PerformOperation((x, y) => x + y, 5, 3); // Adds 5 and 3
public delegate int MyDelegate(int x, int y);
public class Calculator
{
    public int PerformOperation(MyDelegate operation, int operand1, int operand2)
    {
        return operation(operand1, operand2);
    }
}
// Usage
var calculator = new Calculator();
int result = calculator.PerformOperation((x, y) => x + y, 5, 3); // Adds 5 and 3
Public Delegate Function MyDelegate(ByVal x As Integer, ByVal y As Integer) As Integer
Public Class Calculator
	Public Function PerformOperation(ByVal operation As MyDelegate, ByVal operand1 As Integer, ByVal operand2 As Integer) As Integer
		Return operation(operand1, operand2)
	End Function
End Class
' Usage
Private calculator = New Calculator()
Private result As Integer = calculator.PerformOperation(Function(x, y) x + y, 5, 3) ' Adds 5 and 3
$vbLabelText   $csharpLabel

Presentación de IronPDF: Un breve resumen

Delegados en C# (Cómo Funciona para Desarrolladores): Figura 1 - Página web de IronPDF

Descubre más sobre las características de IronPDF como una biblioteca rica en funciones diseñada para facilitar la generación, manipulación e interacción de archivos PDF en aplicaciones C#. Tanto si necesita crear PDF desde cero, convertir HTML a PDF o extraer contenido de PDF existentes, IronPDF le ofrece un completo conjunto de herramientas para agilizar estas tareas. Su versatilidad lo convierte en un activo valioso para los desarrolladores que trabajan en proyectos muy diversos.

Instalación de IronPDF: Inicio rápido

Para empezar a aprovechar la biblioteca IronPDF en su proyecto C#, puede instalar fácilmente el paquete IronPDF NuGet. Utilice el siguiente comando en la consola del gestor de paquetes:

Install-Package IronPdf

También puede buscar "IronPDF" en el gestor de paquetes NuGet e instalarlo desde allí.

Delegados en C# (cómo funciona para desarrolladores): Figura 2 - Instalando la biblioteca IronPDF a través del Administrador de Paquetes NuGet

Delegados en C#: Un breve resumen

En C#, los delegados sirven como punteros a funciones seguras, permitiendo que los métodos sean referenciados y pasados como parámetros. Los delegados desempeñan un papel crucial en los distintos escenarios mencionados. Ahora, surge la pregunta: ¿Cómo encajan los delegados de C# en el entorno de IronPDF, y pueden utilizarse eficazmente en tándem?

Integración de delegados con IronPDF

1. Uso de métodos de devolución de llamada para eventos de documento

Una forma de aprovechar los delegados con IronPDF es a través de llamadas de retorno para eventos de documentos. IronPDF proporciona eventos a los que puede suscribirse utilizando delegados, lo que le permite ejecutar lógica personalizada en puntos específicos durante el proceso de generación de documentos. Por ejemplo:

string AddPassword(PdfDocument document)
{
    string password = "";
    if (document.Password == "")
    {
        password = "Iron123";   
    }
    return password;
}
PdfDocument document = new PdfDocument("StyledDocument.pdf");
AddPasswordEventHandler handler = AddPassword;
document.Password = handler.Invoke(document);  // Subscribe to the event
document.SaveAs("PasswordProtected.pdf");
public delegate string AddPasswordEventHandler(PdfDocument e);
string AddPassword(PdfDocument document)
{
    string password = "";
    if (document.Password == "")
    {
        password = "Iron123";   
    }
    return password;
}
PdfDocument document = new PdfDocument("StyledDocument.pdf");
AddPasswordEventHandler handler = AddPassword;
document.Password = handler.Invoke(document);  // Subscribe to the event
document.SaveAs("PasswordProtected.pdf");
public delegate string AddPasswordEventHandler(PdfDocument e);
Private Function AddPassword(ByVal document As PdfDocument) As String
	Dim password As String = ""
	If document.Password = "" Then
		password = "Iron123"
	End If
	Return password
End Function
Private document As New PdfDocument("StyledDocument.pdf")
Private handler As AddPasswordEventHandler = AddressOf AddPassword
document.Password = handler.Invoke(document) ' Subscribe to the event
document.SaveAs("PasswordProtected.pdf")
public delegate String AddPasswordEventHandler(PdfDocument e)
$vbLabelText   $csharpLabel

En este fragmento de código C#, se define un método llamado AddPassword para aceptar un PdfDocument como parámetro y devolver una cadena. Dentro de este método, se inicializa una variable de tipo cadena llamada password, y se realiza una comprobación condicional en la propiedad Password del PdfDocument proporcionado. Si la contraseña es una cadena vacía, asigna el valor "Iron123" a la variable password y devuélvela.

A continuación, se crea una instancia de PdfDocument con el nombre de archivo "StyledDocument.pdf". Se declara un delegado llamado AddPasswordEventHandler con la misma firma que el método AddPassword. Una instancia de este delegado, llamado handler, se asigna al método AddPassword. El delegado se invoca luego con el método Invoke, pasando la instancia del document, y la contraseña devuelta se asigna a la propiedad Password del document.

Finalmente, se llama al método SaveAs en el document, guardándolo como "PasswordProtected.pdf". El código utiliza de manera efectiva un delegado para determinar y establecer dinámicamente una contraseña para un PdfDocument basado en ciertas condiciones dentro del método AddPassword.

2. Uso de delegados para contenido dinámico

Los delegados también pueden emplearse para inyectar contenido dinámico en el documento PDF. IronPDF admite la inserción de contenido HTML para generar PDFs desde HTML, y los desarrolladores pueden usar delegados para generar HTML dinámicamente según ciertas condiciones o datos:

// Assuming GetDynamicContent is a delegate that generates dynamic HTML content
Func<string> getDynamicContent = () =>
{
    // Custom logic to generate dynamic content
    return "<p>This is dynamic content based on some condition.</p>";
};
// Incorporate dynamic HTML into the PDF
var pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>").SaveAs("DynamicContentDocument.pdf");
// Assuming GetDynamicContent is a delegate that generates dynamic HTML content
Func<string> getDynamicContent = () =>
{
    // Custom logic to generate dynamic content
    return "<p>This is dynamic content based on some condition.</p>";
};
// Incorporate dynamic HTML into the PDF
var pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>").SaveAs("DynamicContentDocument.pdf");
' Assuming GetDynamicContent is a delegate that generates dynamic HTML content
Dim getDynamicContent As Func(Of String) = Function()
	' Custom logic to generate dynamic content
	Return "<p>This is dynamic content based on some condition.</p>"
End Function
' Incorporate dynamic HTML into the PDF
Dim pdfDocument = New ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>").SaveAs("DynamicContentDocument.pdf")
$vbLabelText   $csharpLabel

En este ejemplo, el delegado getDynamicContent genera contenido HTML dinámicamente, el cual luego se incrusta en el documento PDF.

Delegados en C# (Cómo funciona para desarrolladores): Figura 3 - PDF generado a partir del código anterior

Para hacer uso de IronPDF de manera eficiente y efectiva, por favor visita la documentación de IronPDF.

Conclusión

En conclusión, los delegados de C# son la piedra angular de la flexibilidad y modularidad del código. Permiten a los desarrolladores implementar retrollamadas, gestionar eventos y adoptar paradigmas de programación funcional, como la posibilidad de modificar mediante programación las llamadas a métodos. Como herramienta versátil del conjunto de herramientas de C#, los delegados permiten a los desarrolladores crear código más fácil de mantener, escalable y expresivo. Tanto si está creando aplicaciones basadas en eventos, implementando mecanismos de devolución de llamada o explorando la programación funcional, los delegados de C# son un poderoso aliado en su viaje por la programación.

Los delegados de C# y IronPDF pueden formar un dúo cooperativo, mejorando las capacidades de generación de documentos en sus aplicaciones. Tanto si está personalizando eventos de documentos o inyectando contenido dinámico, los delegados proporcionan un mecanismo flexible para ampliar la funcionalidad de IronPDF. Mientras explora las posibilidades, considere los requisitos específicos de su proyecto y cómo pueden contribuir los delegados a un proceso de generación de PDF más personalizado y dinámico con IronPDF.

IronPDF ofrece una prueba gratuita para probar su funcionalidad completa. Se puede licenciar para uso comercial a partir de $749.

Chipego
Ingeniero de software
Chipego tiene una habilidad natural para escuchar que le ayuda a comprender los problemas de los clientes y a ofrecer soluciones inteligentes. Se unió al equipo de Iron Software en 2023, después de estudiar una licenciatura en Tecnología de la Información. IronPDF e IronOCR son los dos productos en los que Chipego se ha centrado, pero su conocimiento de todos los productos crece día a día, a medida que encuentra nuevas formas de ayudar a los clientes. Disfruta de lo colaborativa que es la vida en Iron Software, con miembros del equipo de toda la empresa que aportan su variada experiencia para contribuir a soluciones eficaces e innovadoras. Cuando Chipego está lejos de su escritorio, a menudo se le puede encontrar disfrutando de un buen libro o jugando al fútbol.
< ANTERIOR
Atributos en C# (Cómo funciona para desarrolladores)
SIGUIENTE >
Operador ternario en C# (Cómo funciona para desarrolladores)