0Pricing
C# Academy · Lección

delegate, Action/Func y cierres

Transmita comportamiento mediante delegates: declare delegates personalizados, use Action/Func integrados y descubra cómo las lambdas capturan variables (cierres).

delegate, Action/Func y cierres es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Descripción general de los delegados

Objetivo: Tratar los métodos como datos.

  • Defina un tipo delegate
  • Use Action/Func
  • Cree lambdas
  • Comprenda los cierres (variables capturadas)

Conceptos básicos de delegados personalizados

Un delegate es un puntero a función con seguridad de tipos. Asigne métodos compatibles e invoque el delegado como una función.

using System;

// Custom delegate type: a method taking two ints and returning int
public delegate int Op(int x, int y);

public class Program
{
  static int Add(int a, int b) { return a + b; }
  static int Mul(int a, int b) { return a * b; }

  public static void Main(string[] args)
  {
    Op f = Add;                // method group conversion
    Console.WriteLine(f(2, 3)); // 5
    f = Mul;
    Console.WriteLine(f(2, 3)); // 6
  }
}

Action y Func

Action representa métodos que devuelven void; Func devuelve un valor. Use grupos de métodos o lambdas.

using System;

public class Program
{
  static void Log(string s) { Console.WriteLine("LOG: " + s); }

  public static void Main(string[] args)
  {
    Action<string> a = Log;                        // no return
    a("hello");

    Func<int, int, int> sum = delegate(int x, int y) { return x + y; }; // lambda/anon method
    Console.WriteLine(sum(3, 4)); // 7

    // Method group to Func
    Func<string, int> len = GetLen;
    Console.WriteLine(len("abc")); // 3
  }

  static int GetLen(string s) { return s == null ? 0 : s.Length; }
}

Demostración de cierres

Un cierre captura variables del ámbito externo. La variable sobrevive al método que creó el delegado.

using System;

public class Program
{
  public static void Main(string[] args)
  {
    int counter = 0; // captured variable (lives as long as delegate)
    Action inc = delegate() { counter = counter + 1; Console.WriteLine(counter); };

    inc(); // 1
    inc(); // 2
    Console.WriteLine("Final=" + counter); // 2
  }
}

Método de orden superior

Pase un Func o Action para personalizar el comportamiento. Esta es la base de muchas API (incluido LINQ).

using System;

public class Program
{
  // Apply a transform to each number and sum the results
  static int SumBy(int[] xs, Func<int, int> transform)
  {
    int total = 0;
    for (int i = 0; i < xs.Length; i++)
    {
      total += transform(xs[i]);
    }
    return total;
  }

  public static void Main(string[] args)
  {
    int[] data = new int[] { 1, 2, 3 };
    int sumSquares = SumBy(data, delegate(int x) { return x * x; });
    Console.WriteLine(sumSquares); // 14
  }
}

Consejos sobre delegados

Consejos:

  • Prefiera Action/Func para evitar tipos de delegados personalizados adicionales.
  • Mantenga las lambdas breves y claras.
  • Preste atención a las variables capturadas; su valor puede cambiar posteriormente.
  • Use grupos de métodos cuando un método con nombre ya coincida con la firma.

Significado de Func frente a Action

Comprobación rápida: ¿Qué tipo de delegado integrado representa un método que devuelve un valor?

Repaso

Repaso: Declare delegados, use Action/Func y escriba lambdas pequeñas. Los cierres permiten que las lambdas capturen variables locales; úselos con cuidado.

Preguntas frecuentes

¿La lección «delegate, Action/Func y cierres» es gratis?

Sí — el texto completo de «delegate, Action/Func y cierres» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «delegate, Action/Func y cierres»?

Transmita comportamiento mediante delegates: declare delegates personalizados, use Action/Func integrados y descubra cómo las lambdas capturan variables (cierres). Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 3.

¿Cuánto tiempo toma la lección «delegate, Action/Func y cierres»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. delegate, Action/Func y cierres
  2. Eventos: publicación/suscripción y palabra clave event
  3. Patrones de eventos y errores comunes (fugas de memoria)
← Volver a C# Academy