0Pricing
C# Academy · Lección

Funciones locales estáticas

Evite las capturas para mejorar la claridad y el rendimiento.

Funciones locales estáticas es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 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 estáticas

Marcar una función local como static le impide capturar variables del ámbito contenedor o this. Esto hace que la función sea independiente, más clara y libre de asignaciones ocultas de clausuras.

Declarar una función local estática

Añada el modificador static antes del tipo de retorno. La función aún puede aceptar parámetros y devolver valores; simplemente no puede acceder a las variables locales externas.

using System;

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

        Console.WriteLine(Square(6));
    }
}

No se permite capturar

Una función local estática no puede utilizar variables locales del ámbito contenedor. Todo lo que necesite debe recibirlo como parámetro, lo que hace explícitas sus entradas.

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        // factor must be passed in, not captured
        static int Scale(int n, int f) => n * f;

        Console.WriteLine(Scale(5, factor));
    }
}

Evitar asignaciones ocultas

Las funciones locales no estáticas que capturan variables pueden asignar un objeto de clausura oculto. Una función local estática nunca captura, por lo que evita por completo esa asignación.

using System;

public class Program
{
    public static void Main()
    {
        // Pure helper, no closure object created
        static bool IsEven(int n) => n % 2 == 0;

        for (int i = 0; i < 5; i++)
            Console.WriteLine(i + ": " + IsEven(i));
    }
}

Intención autoexplicativa

La palabra clave static indica a los lectores que el auxiliar solo depende de sus argumentos. Esta garantía facilita razonar sobre la función y probarla.

using System;

public class Program
{
    public static void Main()
    {
        static int Clamp(int value, int lo, int hi)
            => value < lo ? lo : value > hi ? hi : value;

        Console.WriteLine(Clamp(15, 0, 10));
        Console.WriteLine(Clamp(-3, 0, 10));
    }
}

El compilador impone la ausencia de captura

Si referencia accidentalmente una variable local del ámbito contenedor dentro de una función local estática, el compilador informa de un error. Esto detecta pronto las dependencias no deseadas.

using System;

public class Program
{
    public static void Main()
    {
        int seed = 7;
        // Correct: seed is passed explicitly, not captured
        static int Mix(int x, int s) => x * 31 + s;

        Console.WriteLine(Mix(2, seed));
    }
}

Funciones locales estáticas con recursividad

Las funciones locales estáticas siguen admitiendo la recursividad, ya que llamarse a sí mismas no equivale a capturar una variable.

using System;

public class Program
{
    public static void Main()
    {
        static int Power(int baseN, int exp)
            => exp == 0 ? 1 : baseN * Power(baseN, exp - 1);

        Console.WriteLine(Power(2, 10));
    }
}

Combinar con parámetros out

Al igual que cualquier método, las funciones locales estáticas pueden utilizar parámetros out, lo que combina bien su pureza sin captura con los auxiliares de estilo try-parse.

using System;

public class Program
{
    public static void Main()
    {
        static bool TryParsePositive(string s, out int value)
        {
            value = 0;
            return int.TryParse(s, out value) && value > 0;
        }

        if (TryParsePositive("42", out int n))
            Console.WriteLine("got " + n);
        Console.WriteLine(TryParsePositive("-1", out _));
    }
}

Pasar funciones locales estáticas como delegados

Como no capturan nada, las funciones locales estáticas se convierten en delegados sin asignar una clausura, lo que puede ser importante en rutas críticas de ejecución.

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

public class Program
{
    public static void Main()
    {
        static bool IsBig(int n) => n > 100;

        var nums = new List<int> { 50, 150, 200, 10 };
        Console.WriteLine(nums.Count(IsBig));
    }
}

Cuándo preferir static

Prefiera una función local estática siempre que el auxiliar no necesite el estado contenedor. Documenta la pureza, evita capturas accidentales y puede ser más eficiente. Omita static solo cuando realmente necesite capturar variables locales.

using System;

public class Program
{
    public static void Main()
    {
        static string Describe(int score)
        {
            if (score >= 90) return "A";
            if (score >= 80) return "B";
            return "C";
        }

        Console.WriteLine(Describe(95));
        Console.WriteLine(Describe(82));
    }
}

Pruébelo usted mismo

Escriba una función local estática pura y pásela como predicado a LINQ. Como no captura nada, se convierte en un delegado sin crear una clausura.

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

public class Program
{
    public static void Main()
    {
        static bool IsLeapYear(int year)
            => (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

        var years = new List<int> { 1900, 2000, 2004, 2021, 2024 };
        Console.WriteLine(string.Join(", ", years.Where(IsLeapYear)));
    }
}

Comprobación rápida

Recuerde qué aporta static a una función local.

Recapitulación

Una función local static no captura nada.

  • No puede utilizar variables locales del ámbito contenedor ni this; pase los datos mediante parámetros.
  • Evita las asignaciones ocultas de clausuras.
  • El compilador impone la regla de no capturar, detectando dependencias accidentales.
  • Prefiérala siempre que el auxiliar no necesite el estado contenedor.

Preguntas frecuentes

¿La lección «Funciones locales estáticas» es gratis?

Sí — el texto completo de «Funciones locales estáticas» 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 estáticas»?

Evite las capturas para mejorar la claridad y el rendimiento. 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 3 de 4.

¿Cuánto tiempo toma la lección «Funciones locales estáticas»?

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