Fácil C#

Delegate personalizado para operações matemáticas

Enunciado

Crie um delegate chamado Calculadora que recebe dois inteiros e retorna um inteiro. No método Main, atribua a esse delegate uma expressão lambda que soma dois números e outra que multiplica. Exiba o resultado de cada operação.

Requisitos

  • Declare um delegate Calculadora com dois parâmetros int e retorno int.
  • Use uma variável do tipo Calculadora para armazenar a lambda de soma.
  • Use a mesma variável para armazenar a lambda de multiplicação e exiba ambos os resultados.

Código inicial

using System;

// TODO: declare o delegate Calculadora

public class Programa
{
    public static void Main()
    {
        // TODO: crie as lambdas e exiba os resultados
    }
}

Saída esperada

Soma: 7
Multiplicação: 12
Ver dica

Lembre-se de que um delegate pode ser reatribuído como qualquer variável. Use Calculadora calc = (a, b) => a + b; e depois calc = (a, b) => a * b;.

Mostrar solução 
using System;

// Declaração do delegate personalizado
public delegate int Calculadora(int a, int b);

public class Programa
{
    public static void Main()
    {
        // Atribui uma lambda de soma ao delegate
        Calculadora calc = (a, b) => a + b;
        Console.WriteLine($"Soma: {calc(3, 4)}");

        // Reatribui o delegate para a multiplicação
        calc = (a, b) => a * b;
        Console.WriteLine($"Multiplicação: {calc(3, 4)}");
    }
}

Passo a passo

  1. Declaramos o delegate Calculadora com a assinatura int Calculadora(int a, int b). Isso define o contrato que qualquer método referenciado deve seguir.
  2. No Main, criamos a variável calc do tipo Calculadora e atribuímos uma expressão lambda (a, b) => a + b. O compilador converte a lambda para o delegate.
  3. Chamamos calc(3, 4) e imprimimos o resultado. O delegate invoca o método encapsulado.
  4. Reatribuímos calc para a lambda de multiplicação. O delegate agora aponta para outro método.
  5. Chamamos novamente e imprimimos o novo resultado.

Por que funciona

O delegate é um tipo que encapsula um método com uma assinatura específica. Ao atribuir uma lambda, criamos uma instância do delegate que aponta para o código da lambda. Como delegates são objetos, podemos reatribuí-los a qualquer momento, desde que a assinatura seja compatível. Isso permite tratar métodos como valores, um dos pilares da programação funcional em C#.

Erros comuns

  • Esquecer de declarar o delegate: se tentar usar Calculadora sem a declaração, o compilador acusa erro CS0246 (tipo não encontrado).
  • Assinatura incompatível: tentar atribuir um método que não corresponde a (int, int) => int gera erro CS0123 (nenhuma sobrecarga corresponde ao delegate).
  • Usar var sem tipo explícito: var calc = (a, b) => a + b; não compila porque o compilador não consegue inferir o tipo do delegate. É preciso declarar Calculadora calc = ... ou usar Func<int, int, int>.

Outra forma de resolver

Usar Func<int, int, int> em vez de declarar um delegate personalizado:

Func<int, int, int> calc = (a, b) => a + b;
Console.WriteLine($"Soma: {calc(3, 4)}");
calc = (a, b) => a * b;
Console.WriteLine($"Multiplicação: {calc(3, 4)}");

Prefira Func quando a assinatura for simples e não precisar de um nome semântico.

Saída esperada

Soma: 7
Multiplicação: 12