C# Academy · Aula

Declarando funções locais

Defina funções auxiliares dentro de métodos.

Declarando funções locais é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 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.

O que é uma função local

Uma função local é um método declarado dentro de outro método. Ela fica visível apenas dentro do membro envolvente, mantendo a lógica auxiliar próxima do local onde é usada e fora da superfície da classe.

Declarando uma função local

Escreva a função local como um método normal, aninhada dentro do corpo. É possível chamá-la antes ou depois da declaração dentro do mesmo escopo.

using System;

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

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

Funções locais com corpo em bloco

As funções locais podem ter corpos completos em bloco, com várias instruções, laços e suas próprias variáveis locais, assim como qualquer 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));
    }
}

Melhorando a legibilidade

As funções locais permitem nomear uma parte da lógica sem poluir a classe com um método privado que apenas um método utiliza. Isso mantém o código relacionado unido.

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

Recursão com funções locais

Uma função local pode chamar a si mesma, tornando fácil expressar a recursão exatamente onde ela é necessária.

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

Funções locais podem ser declaradas depois do uso

Ao contrário das variáveis locais, uma função local pode ser referenciada antes, no método, do ponto em que é declarada. O compilador resolve todo o escopo envolvente.

using System;

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

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

Parâmetros e tipos de retorno

As funções locais oferecem tudo o que os métodos comuns oferecem: vários parâmetros, valores de retorno, parâmetros ref e out e 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);
    }
}

Funções locais genéricas

Uma função local pode ser genérica, parametrizada pelos próprios argumentos de tipo, independentemente do método envolvente.

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

Aninhando funções locais

As próprias funções locais podem conter funções locais. As funções internas ficam visíveis apenas dentro da função pai, permitindo camadas auxiliares com escopo restrito.

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

Funções locais para validação de argumentos

Um padrão comum é validar os argumentos antecipadamente e depois adiar o trabalho real para uma função local. Isso é especialmente útil com iteradores, para que a validação seja executada imediatamente.

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

Quando usar funções locais

Escolha uma função local quando um auxiliar for usado por exatamente um método, se beneficiar de um nome descritivo ou precisar acessar o estado local do método. Isso mantém a classe organizada e a lógica fácil de localizar.

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

Verificação rápida

Relembre o que é uma função local.

Recapitulação

As funções locais são auxiliares nomeados aninhados dentro de um método.

Ficam visíveis apenas dentro do membro envolvente.
Oferecem suporte a parâmetros, retornos, out/ref, genéricos e recursão.
Podem ser referenciadas antes da declaração.
São excelentes para auxiliares usados uma única vez e para a validação antecipada de argumentos em iteradores.

Perguntas Frequentes

A aula “Declarando funções locais” é grátis?

Sim — o texto completo de “Declarando funções locais” é 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 “Declarando funções locais”?

Defina funções auxiliares dentro de métodos. 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 1 de 4.

Quanto tempo leva a aula “Declarando funções locais”?

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