0Pricing
C# Academy · Lección

Declaración de funciones locales

Defina funciones auxiliares dentro de métodos.

Declaración de funciones locales es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 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.

¿Qué es una función local?

Una función local es un método declarado dentro de otro método. Solo está visible dentro del miembro que la contiene, lo que mantiene la lógica auxiliar cerca del lugar donde se utiliza y fuera de la superficie de la clase.

Declarar una función local

Escriba la función local como un método normal, anidada dentro del cuerpo. Puede llamarla antes o después de su declaración dentro del mismo ámbito.

using System;

public class Program
{
    public static void Main()
    {
        int Square(int n) => n * n;

        Console.WriteLine(Square(4));
        Console.WriteLine(Square(7));
    }
}

Funciones locales con cuerpo de bloque

Las funciones locales pueden tener cuerpos de bloque completos con varias instrucciones, bucles y sus propias variables locales, igual que cualquier método.

using System;

public class Program
{
    public static void Main()
    {
        int Factorial(int n)
        {
            int result = 1;
            for (int i = 2; i <= n; i++) result *= i;
            return result;
        }

        Console.WriteLine(Factorial(5));
    }
}

Mejorar la legibilidad

Las funciones locales permiten asignar un nombre a una parte de la lógica sin llenar la clase con un método privado que solo utiliza un método. Así se mantiene unido el código relacionado.

using System;

public class Program
{
    public static void Main()
    {
        string Format(string label, int value) => label + ": " + value;

        Console.WriteLine(Format("Score", 90));
        Console.WriteLine(Format("Level", 3));
    }
}

Recursividad con funciones locales

Una función local puede llamarse a sí misma, lo que facilita expresar la recursividad justo donde se necesita.

using System;

public class Program
{
    public static void Main()
    {
        int Fib(int n) => n < 2 ? n : Fib(n - 1) + Fib(n - 2);

        for (int i = 0; i < 7; i++)
            Console.Write(Fib(i) + " ");
        Console.WriteLine();
    }
}

Las funciones locales se pueden declarar después de usarlas

A diferencia de las variables locales, una función local puede referenciarse antes del lugar donde se declara dentro del método. El compilador resuelve todo el ámbito contenedor.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Greet("Ada")); // used before declared

        string Greet(string name) => "Hello, " + name;
    }
}

Parámetros y tipos de retorno

Las funciones locales admiten todo lo que admiten los métodos normales: varios parámetros, valores de retorno, parámetros ref y out, y genéricos.

using System;

public class Program
{
    public static void Main()
    {
        bool TryHalve(int n, out int half)
        {
            half = n / 2;
            return n % 2 == 0;
        }

        if (TryHalve(10, out int result))
            Console.WriteLine("half is " + result);
    }
}

Funciones locales genéricas

Una función local puede ser genérica y estar parametrizada con sus propios argumentos de tipo, independientemente del método que la contiene.

using System;

public class Program
{
    public static void Main()
    {
        T Echo<T>(T value)
        {
            Console.WriteLine("echoing " + value);
            return value;
        }

        int n = Echo(42);
        string s = Echo("hi");
        Console.WriteLine(n + " " + s);
    }
}

Anidar funciones locales

Las funciones locales pueden contener a su vez otras funciones locales. Las funciones internas solo están visibles dentro de su función principal, lo que permite crear capas auxiliares con un ámbito muy restringido.

using System;

public class Program
{
    public static void Main()
    {
        int Compute(int x)
        {
            int Double(int n) => n * 2;
            int AddOne(int n) => n + 1;
            return Double(AddOne(x));
        }

        Console.WriteLine(Compute(5));
    }
}

Funciones locales para validar argumentos

Un patrón habitual consiste en validar los argumentos de forma inmediata y delegar después el trabajo real en una función local. Esto resulta especialmente útil con los iteradores, para que la validación se ejecute de inmediato.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Range(int start, int count)
    {
        if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
        return Iterate();

        IEnumerable<int> Iterate()
        {
            for (int i = 0; i < count; i++) yield return start + i;
        }
    }

    public static void Main()
    {
        foreach (var n in Range(10, 3)) Console.WriteLine(n);
    }
}

Cuándo usar funciones locales

Use una función local cuando un auxiliar lo utilice exactamente un método, se beneficie de un nombre descriptivo o necesite acceder al estado local del método. Así mantiene limpia la clase y facilita descubrir la lógica.

using System;

public class Program
{
    public static void Main()
    {
        int total = 0;
        void Add(int n) => total += n; // helper tied to this method
        Add(3); Add(4); Add(5);
        Console.WriteLine(total);
    }
}

Comprobación rápida

Recuerde qué es una función local.

Recapitulación

Las funciones locales son auxiliares con nombre anidados dentro de un método.

  • Solo están visibles dentro del miembro que las contiene.
  • Admiten parámetros, valores de retorno, out/ref, genéricos y recursividad.
  • Se pueden referenciar antes de su declaración.
  • Son ideales para auxiliares de un solo uso y para validar argumentos de forma inmediata en iteradores.

Preguntas frecuentes

¿La lección «Declaración de funciones locales» es gratis?

Sí — el texto completo de «Declaración de funciones locales» 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 «Declaración de funciones locales»?

Defina funciones auxiliares dentro de métodos. 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 4.

¿Cuánto tiempo toma la lección «Declaración de funciones locales»?

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. Declaración de funciones locales
  2. Clausuras y variables capturadas
  3. Funciones locales estáticas
  4. Funciones locales frente a lambdas
← Volver a C# Academy