C# Academy · Lección

Funciones locales frente a lambdas

Elija entre funciones locales y lambdas.

Lección 4 de 413 pasos

Funciones locales frente a lambdas es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. 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 4 lecciones en total.

Funciones locales frente a lambdas

Tanto las funciones locales como las lambdas permiten definir funciones pequeñas dentro de un método. Se solapan en gran medida, pero difieren en sintaxis, capacidades y rendimiento. Elegir la opción adecuada mantiene el código claro y eficiente.

Dos formas de escribir un auxiliar

Aquí se escribe el mismo auxiliar para elevar al cuadrado tanto como función local como lambda asignada a un delegado. Ambas producen el mismo resultado.

using System;

public class Program
{
    public static void Main()
    {
        int SquareFn(int n) => n * n;       // local function
        Func<int, int> squareLambda = n => n * n; // lambda

        Console.WriteLine(SquareFn(4));
        Console.WriteLine(squareLambda(4));
    }
}

Las funciones locales permiten la recursividad fácilmente

Una función local puede llamarse a sí misma por su nombre. Una lambda no puede referenciar su propia variable durante la inicialización, por lo que la recursividad resulta incómoda con lambdas.

using System;

public class Program
{
    public static void Main()
    {
        // Clean recursion with a local function
        int Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
        Console.WriteLine(Factorial(5));
    }
}

Las funciones locales pueden ser genéricas

Las funciones locales admiten sus propios parámetros de tipo. Las lambdas no pueden ser genéricas, por lo que una función local es la opción adecuada para auxiliares tipados reutilizables.

using System;

public class Program
{
    public static void Main()
    {
        T First<T>(T[] items) => items[0]; // generic local function

        Console.WriteLine(First(new[] { 9, 8, 7 }));
        Console.WriteLine(First(new[] { "a", "b" }));
    }
}

Rendimiento: evitar la asignación de delegados

Una lambda asignada a un delegado puede asignar un objeto delegado y, si captura, una clausura. Una función local llamada directamente evita ambas asignaciones, algo importante en bucles críticos de ejecución.

using System;

public class Program
{
    public static void Main()
    {
        // Direct call, no delegate or closure allocation
        static int Add(int a, int b) => a + b;

        int total = 0;
        for (int i = 0; i < 5; i++) total = Add(total, i);
        Console.WriteLine(total);
    }
}

Parámetros out y ref

Las funciones locales pueden declarar parámetros out y ref; las lambdas que utilizan los delegados comunes Func/Action no pueden. Esto hace que los auxiliares de estilo try-parse resulten naturales como funciones locales.

using System;

public class Program
{
    public static void Main()
    {
        bool TryGetFirstDigit(string s, out int digit)
        {
            digit = 0;
            foreach (var c in s)
                if (char.IsDigit(c)) { digit = c - '0'; return true; }
            return false;
        }

        if (TryGetFirstDigit("abc4", out int d))
            Console.WriteLine(d);
    }
}

Las lambdas destacan como argumentos en línea

Cuando necesite pasar comportamiento directamente a un método como LINQ Where o Select, una lambda es la opción más concisa y legible.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
        var evens = nums.Where(n => n % 2 == 0).Select(n => n * 10);
        Console.WriteLine(string.Join(", ", evens));
    }
}

La captura funciona en ambos casos

Ambas formas pueden capturar variables del ámbito envolvente. La diferencia está principalmente en la sintaxis y el coste de asignación, no en si es posible capturar variables.

using System;

public class Program
{
    public static void Main()
    {
        int bonus = 10;
        int WithBonusFn(int n) => n + bonus;     // captures
        Func<int, int> withBonusLambda = n => n + bonus; // captures

        Console.WriteLine(WithBonusFn(5));
        Console.WriteLine(withBonusLambda(5));
    }
}

Asignación definida y orden

Una función local puede llamarse antes de su declaración dentro del método; una variable lambda debe asignarse antes de utilizarla. Esto ofrece a las funciones locales una ubicación más flexible.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Triple(4)); // allowed before declaration

        int Triple(int n) => n * 3;
    }
}

Cómo elegir entre ambas

Use una función local para auxiliares con nombre, reutilizables, recursivos, genéricos o destinados a rutas críticas. Use una lambda para comportamientos breves en línea que se pasan directamente a otro método. Ambas son herramientas; elija según la intención.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        static bool IsPrime(int n)
        {
            if (n < 2) return false;
            for (int i = 2; i * i <= n; i++)
                if (n % i == 0) return false;
            return true;
        }

        var primes = Enumerable.Range(2, 20).Where(IsPrime);
        Console.WriteLine(string.Join(", ", primes));
    }
}

Pruébelo usted mismo

Use una función local recursiva para la lógica principal y una lambda para la proyección LINQ en línea, de modo que cada construcción haga aquello para lo que resulta más adecuada.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        // Local function: recursive, named, reusable
        static int DigitCount(int n) => Math.Abs(n) < 10 ? 1 : 1 + DigitCount(n / 10);

        var nums = new List<int> { 5, 42, 1000, 7, 88 };
        // Lambda: concise inline projection
        var report = nums.Select(n => n + " has " + DigitCount(n) + " digits");
        foreach (var line in report) Console.WriteLine(line);
    }
}

Comprobación rápida

Compare ambas construcciones.

Responde en la lección interactiva

Resumen

Las funciones locales y las lambdas se solapan, pero se diferencian en aspectos importantes.

Las funciones locales pueden ser recursivas y genéricas, y pueden usar out/ref.
Cuando se llaman directamente, evitan las asignaciones de delegados y cierres.
Las lambdas son especialmente concisas como argumentos en línea de métodos como LINQ.
Elija según la intención: un auxiliar reutilizable con nombre o un comportamiento breve en línea.

Gratis para empezar

Aprende C# con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 93
Lecciones: 346

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Funciones locales frente a lambdas» es gratis?

Sí — el texto completo de «Funciones locales frente a lambdas» 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 4 lecciones en total.

¿Qué aprenderé en «Funciones locales frente a lambdas»?

Elija entre funciones locales y lambdas. 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 4 de 4.

¿Cuánto tiempo toma la lección «Funciones locales frente a lambdas»?

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

← Volver a C# Academy