C# Academy · Aula

Funções locais versus lambdas

Escolha entre funções locais e lambdas.

Aula 4 de 413 etapas

Funções locais versus lambdas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 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 versus lambdas

Tanto as funções locais quanto as lambdas permitem definir funções pequenas dentro de um método. Elas se sobrepõem bastante, mas diferem na sintaxe, nos recursos e no desempenho. Escolher a opção certa mantém o código claro e eficiente.

Duas formas de escrever um auxiliar

Aqui, o mesmo auxiliar que calcula o quadrado é escrito tanto como uma função local quanto como uma lambda atribuída a um delegado. Ambos produzem o mesmo 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));
    }
}

Funções locais permitem recursão facilmente

Uma função local pode chamar a si mesma pelo nome. Uma lambda não pode referenciar sua própria variável durante a inicialização, portanto a recursão é trabalhosa com 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));
    }
}

Funções locais podem ser genéricas

As funções locais oferecem suporte aos próprios parâmetros de tipo. As lambdas não podem ser genéricas; portanto, para auxiliares tipados reutilizáveis, a escolha é uma função local.

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

Desempenho: evitando alocação de delegados

Uma lambda atribuída a um delegado pode alocar um objeto delegado e, se capturar algo, um fechamento. Uma função local chamada diretamente evita ambos, o que importa em laços críticos.

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 e ref

As funções locais podem declarar parâmetros out e ref; as lambdas, por meio dos delegados comuns Func/Action, não podem. Isso torna naturais como funções locais os auxiliares de análise com tentativa.

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

Expressões lambda brilham como argumentos embutidos

Quando precisar passar um comportamento diretamente para um método como LINQ Where ou Select, uma expressão lambda é a opção mais concisa e legível.

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

A captura funciona para ambas

Ambas as formas podem capturar variáveis do contexto externo. A diferença está principalmente na sintaxe e no custo de alocação, não na possibilidade de captura.

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

Atribuição definida e ordem

Uma função local pode ser chamada antes de sua declaração no método; uma variável que contém uma expressão lambda precisa receber uma atribuição antes de ser usada. Isso dá às funções locais uma disposição mais flexível.

using System;

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

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

Escolhendo entre elas

Use uma função local para auxiliares nomeados, reutilizáveis, recursivos, genéricos ou usados em caminhos críticos. Use uma expressão lambda para um comportamento curto e embutido, passado diretamente a outro método. Ambas são ferramentas; escolha de acordo com a intenção.

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

Experimente

Use uma função local recursiva para a lógica principal e uma expressão lambda para a projeção embutida do LINQ, permitindo que cada construção faça o que faz melhor.

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

Verificação rápida

Compare as duas construções.

Responda na aula interativa

Recapitulação

As funções locais e as expressões lambda se sobrepõem, mas diferem em aspectos importantes.

As funções locais podem ser recursivas, genéricas e usar out/ref.
Quando chamadas diretamente, evitam alocações de delegados e fechamentos.
As expressões lambda são mais concisas como argumentos embutidos para métodos como o LINQ.
Escolha pela intenção: auxiliar nomeado e reutilizável versus comportamento curto e embutido.

Grátis para começar

Aprenda C# com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 93
Aulas: 346

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Funções locais versus lambdas” é grátis?

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

Escolha entre funções locais e lambdas. 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 4 de 4.

Quanto tempo leva a aula “Funções locais versus lambdas”?

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