C# Academy · Aula

Funções locais estáticas

Evite capturas para obter clareza e desempenho.

Funções locais estáticas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Funções locais estáticas

Marcar uma função local como static impede que ela capture quaisquer variáveis envolventes ou this. Isso torna a função autossuficiente, mais clara e livre de alocações ocultas de fechamentos.

Declarando uma função local estática

Adicione o modificador static antes do tipo de retorno. A função ainda pode receber parâmetros e retornar valores; ela simplesmente não pode acessar variáveis locais externas.

using System;

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

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

Nenhuma captura permitida

Uma função local estática não pode usar variáveis locais envolventes. Tudo de que precisa deve ser passado como parâmetro, tornando suas entradas explícitas.

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));
    }
}

Evitando alocações ocultas

Funções locais não estáticas que capturam variáveis podem alocar um objeto de fechamento oculto. Uma função local estática nunca captura nada, portanto evita completamente essa alocação.

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));
    }
}

Intenção autoexplicativa

A palavra-chave static indica aos leitores que o auxiliar depende apenas dos próprios argumentos. Essa garantia torna a função mais fácil de compreender e testar.

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));
    }
}

O compilador impõe a ausência de captura

Se você referenciar acidentalmente uma variável local envolvente dentro de uma função local estática, o compilador relatará um erro. Isso detecta dependências não intencionais antecipadamente.

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));
    }
}

Variáveis locais estáticas com recursão

As funções locais estáticas ainda oferecem suporte à recursão, pois chamar a si mesmas não é o mesmo que capturar uma variável.

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));
    }
}

Combinando com parâmetros out

Assim como qualquer método, as funções locais estáticas podem usar parâmetros out, o que combina bem com sua pureza sem captura para auxiliares de análise com tentativa.

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 _));
    }
}

Passando funções locais estáticas como delegados

Como não capturam nada, as funções locais estáticas são convertidas em delegados sem alocar um fechamento, o que pode ser importante em caminhos críticos.

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));
    }
}

Quando preferir static

Prefira uma função local estática sempre que o auxiliar não precisar do estado envolvente. Isso documenta a pureza, impede capturas acidentais e pode ser mais eficiente. Omita static somente quando realmente precisar capturar variáveis locais.

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));
    }
}

Experimente por si mesmo

Escreva uma função local estática pura e passe-a como um predicado para o LINQ. Como ela não captura nada, é convertida em um delegado sem fechamento.

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)));
    }
}

Verificação rápida

Relembre o que static acrescenta a uma função local.

Recapitulação

Uma função local static não captura nada.

Ela não pode usar variáveis locais envolventes nem this; passe os dados por meio de parâmetros.
Evita alocações ocultas de fechamentos.
O compilador impõe a regra de ausência de captura, detectando dependências acidentais.
Prefira-a sempre que o auxiliar não precisar do estado envolvente.

Perguntas Frequentes

A aula “Funções locais estáticas” é grátis?

Sim — o texto completo de “Funções locais estáticas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Funções locais estáticas”?

Evite capturas para obter clareza e desempenho. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Funções locais estáticas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy