Da trilha de C# Este conceito ainda não saiu como card do dia. ir para o card de hoje

C# Funções Intermediário

Lambdas

As expressões lambda são funções anônimas que podem ser usadas para criar delegates ou árvores de expressão. Em C#, a sintaxe (parâmetros) => expressão ou (parâmetros) => { bloco } permite escrever código conciso, especialmente útil com LINQ e métodos que aceitam delegates como Action, Func ou Predicate.

Um aspecto poderoso das lambdas é a captura de variáveis do escopo externo. Isso significa que a lambda pode acessar e modificar variáveis locais ou campos da classe onde foi definida. No entanto, é preciso ter cuidado com o tempo de vida dessas variáveis e possíveis efeitos colaterais.

Lambdas podem ser passadas como argumentos para métodos que esperam delegates, como em List<T>.ForEach, Where, Select, etc. Além disso, a partir do C# 9, podemos declarar static lambdas usando a palavra-chave static antes dos parâmetros, o que impede a captura de variáveis externas e pode melhorar o desempenho e a clareza.

Pontos-chave

  • Lambdas são funções anônimas escritas com =>.
  • Lambdas podem capturar variáveis do escopo externo (closures).
  • Lambdas são frequentemente usadas como argumentos para métodos que recebem delegates.
  • static lambdas não podem capturar variáveis externas, evitando alocações desnecessárias.
  • A captura em lambdas dentro de loops pode causar comportamentos inesperados se não forem tomadas precauções.
LambdasDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        // Lambda simples como Func<int, int>
        Func<int, int> quadrado = x => x * x;
        Console.WriteLine($"Quadrado de 5: {quadrado(5)}");

        // Captura de variável externa
        int fator = 10;
        Func<int, int> multiplica = x => x * fator;
        Console.WriteLine($"5 * {fator} = {multiplica(5)}");

        // Lambda como parâmetro para Where
        var numeros = new List<int> { 1, 2, 3, 4, 5, 6 };
        var pares = numeros.Where(n => n % 2 == 0).ToList();
        Console.WriteLine($"Pares: {string.Join(", ", pares)}");

        // Static lambda (não captura)
        Func<int, int> dobro = static x => x * 2;
        Console.WriteLine($"Dobro de 7: {dobro(7)}");

        // Lambda com bloco de instruções
        Action<string> saudacao = nome =>
        {
            var msg = $"Olá, {nome}!";
            Console.WriteLine(msg);
        };
        saudacao("Mundo");
    }
}

Exercícios

  1. 1
    Fácil

    Lambda que soma dois números

    Crie uma expressão lambda que receba dois inteiros e retorne a soma. Atribua-a a um Func<int, int, int> e use-a para somar 3 e 4, exibindo o resultado no console.

    Resolver
  2. 2
    Médio

    Filtrando com lambda e captura

    Dada uma lista de inteiros, use uma lambda que capture uma variável limite para filtrar apenas os números maiores que esse limite. Exiba os números filtrados separados por vírgula.

    Resolver
  3. 3
    Desafio

    Static lambda e captura acidental

    Crie um programa que demonstre a diferença entre uma lambda comum e uma static lambda. Use uma lista de strings e um Action<string> que imprime cada item com um prefixo capturado. Depois, tente criar uma static lambda que faça o mesmo e observe o erro de compilação. Comente a linha que causa erro e mostre a saída correta.

    Resolver

Continue estudando