C# Academy · Aula

delegate, Action/Func, fechamentos

Passe comportamentos por meio de delegados: declare delegados personalizados, use Action/Func integrados e veja como as lambdas capturam variáveis (fechamentos).

delegate, Action/Func, fechamentos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.

Visão geral dos delegados

Objetivo: tratar métodos como dados.

Defina um tipo delegado
Use Action/Func
Crie expressões lambda
Entenda os fechamentos (variáveis capturadas)

Noções básicas de delegados personalizados

Um delegado é um ponteiro de função com segurança de tipos. Atribua métodos compatíveis e invoque-o como uma função.

using System;

// Custom delegate type: a method taking two ints and returning int
public delegate int Op(int x, int y);

public class Program
{
  static int Add(int a, int b) { return a + b; }
  static int Mul(int a, int b) { return a * b; }

  public static void Main(string[] args)
  {
    Op f = Add;                // method group conversion
    Console.WriteLine(f(2, 3)); // 5
    f = Mul;
    Console.WriteLine(f(2, 3)); // 6
  }
}

Action e Func

Action representa métodos que não retornam valor; Func retorna um valor. Use grupos de métodos ou expressões lambda.

using System;

public class Program
{
  static void Log(string s) { Console.WriteLine("LOG: " + s); }

  public static void Main(string[] args)
  {
    Action<string> a = Log;                        // no return
    a("hello");

    Func<int, int, int> sum = delegate(int x, int y) { return x + y; }; // lambda/anon method
    Console.WriteLine(sum(3, 4)); // 7

    // Method group to Func
    Func<string, int> len = GetLen;
    Console.WriteLine(len("abc")); // 3
  }

  static int GetLen(string s) { return s == null ? 0 : s.Length; }
}

Demonstração de fechamento

Um fechamento captura variáveis do escopo externo. A variável continua existindo depois do método que criou o delegado.

using System;

public class Program
{
  public static void Main(string[] args)
  {
    int counter = 0; // captured variable (lives as long as delegate)
    Action inc = delegate() { counter = counter + 1; Console.WriteLine(counter); };

    inc(); // 1
    inc(); // 2
    Console.WriteLine("Final=" + counter); // 2
  }
}

Método de ordem superior

Passe um Func ou Action para personalizar o comportamento. Essa é a base de muitas APIs (e do LINQ).

using System;

public class Program
{
  // Apply a transform to each number and sum the results
  static int SumBy(int[] xs, Func<int, int> transform)
  {
    int total = 0;
    for (int i = 0; i < xs.Length; i++)
    {
      total += transform(xs[i]);
    }
    return total;
  }

  public static void Main(string[] args)
  {
    int[] data = new int[] { 1, 2, 3 };
    int sumSquares = SumBy(data, delegate(int x) { return x * x; });
    Console.WriteLine(sumSquares); // 14
  }
}

Dicas sobre delegados

Dicas:

Prefira Action/Func para evitar tipos de delegados personalizados adicionais.
Mantenha as expressões lambda curtas e claras.
Preste atenção às variáveis capturadas; o valor delas pode mudar posteriormente.
Use grupos de métodos quando um método nomeado já corresponder à assinatura.

Significado de Func e Action

Verificação rápida: qual tipo de delegado integrado representa um método que retorna um valor?

Recapitulação

Recapitulação: declare delegados, use Action/Func e escreva pequenas expressões lambda. Os fechamentos permitem que as expressões lambda capturem variáveis locais — use esse recurso com cuidado.

Perguntas Frequentes

A aula “delegate, Action/Func, fechamentos” é grátis?

Sim — o texto completo de “delegate, Action/Func, fechamentos” é 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 3 aulas no total.

O que vou aprender em “delegate, Action/Func, fechamentos”?

Passe comportamentos por meio de delegados: declare delegados personalizados, use Action/Func integrados e veja como as lambdas capturam variáveis (fechamentos). 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 3.

Quanto tempo leva a aula “delegate, Action/Func, fechamentos”?

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

delegate, Action/Func, fechamentos
Eventos: publicação/assinatura, palavra-chave event
Padrões de eventos e armadilhas (vazamentos de memória)

← Voltar para C# Academy