C# Academy · Aula

Delegados e eventos

Aprenda como delegados e eventos permitem a comunicação entre objetos em C#

Delegados e eventos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 5 de 6. 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 6 aulas no total.

Delegados e eventos

Bem-vindo à próxima lição! Nesta lição, você aprenderá sobre delegados e eventos em C#, sua finalidade e como eles permitem a programação orientada a eventos. Vamos começar!

O que é um delegate?

Um delegate é um tipo que representa uma referência a um método. Ele permite que métodos sejam passados como parâmetros e invocados dinamicamente.

Ponto principal: Os delegados são essenciais para implementar eventos e funções de retorno de chamada em C#.

Definindo e usando delegados

Para definir um delegado, use a palavra-chave delegate. Exemplo:

using System;

class Program {
    // Define a delegate
    public delegate void MessageDelegate(string message);

    static void DisplayMessage(string message) {
        Console.WriteLine(message);
    }

    static void Main() {
        // Create a delegate instance
        MessageDelegate msg = DisplayMessage;

        // Invoke the delegate
        msg("Hello, Delegates!");
    }
}

Delegados de múltiplos destinos

Um único delegado pode apontar para vários métodos, e todos os métodos serão invocados em ordem. Exemplo:

Dica: Use delegados de múltiplos destinos em situações nas quais várias ações precisam ser executadas.

using System;

class Program {
    public delegate void MessageDelegate(string message);

    static void ShowMessage(string message) {
        Console.WriteLine("Message: " + message);
    }

    static void LogMessage(string message) {
        Console.WriteLine("Log: " + message);
    }

    static void Main() {
        MessageDelegate msg = ShowMessage;
        msg += LogMessage; // Add another method

        msg("Hello, Multicast Delegates!"); // Both methods are invoked
    }
}

O que é um evento?

Um evento é um mecanismo que permite que uma classe notifique outras classes ou objetos quando algo de interesse ocorre. Os eventos são construídos sobre delegados.

Ponto principal: Os eventos permitem um baixo acoplamento entre publicadores e assinantes na programação orientada a eventos.

Definindo e usando eventos

Para definir um evento, use a palavra-chave event com um tipo de delegado. Exemplo:

Ponto principal: Os eventos permitem criar sistemas reativos e orientados a eventos.

using System;

class Publisher {
    public delegate void NotifyDelegate(string message);
    public event NotifyDelegate Notify; // Define an event

    public void RaiseEvent(string message) {
        Notify?.Invoke(message); // Invoke the event
    }
}

class Subscriber {
    public void OnNotify(string message) {
        Console.WriteLine("Subscriber received: " + message);
    }
}

class Program {
    static void Main() {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber();

        pub.Notify += sub.OnNotify; // Subscribe to the event
        pub.RaiseEvent("Hello, Events!"); // Raise the event
    }
}

Cancelando a inscrição em eventos

Os assinantes podem cancelar a inscrição em eventos usando o operador -=`. Exemplo:



Dica: Sempre cancele a inscrição em eventos para evitar vazamentos de memória.

using System;

class Publisher {
    public delegate void NotifyDelegate(string message);
    public event NotifyDelegate Notify;

    public void RaiseEvent(string message) {
        Notify?.Invoke(message);
    }
}

class Subscriber {
    public void OnNotify(string message) {
        Console.WriteLine("Subscriber received: " + message);
    }
}

class Program {
    static void Main() {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber();

        pub.Notify += sub.OnNotify; // Subscribe
        pub.RaiseEvent("First Message");

        pub.Notify -= sub.OnNotify; // Unsubscribe
        pub.RaiseEvent("Second Message"); // No output, as subscriber is removed
    }
}

`Desafio prático`


Crie um delegado CalculationDelegate para operações aritméticas e um evento OnCalculate. Escreva um programa que dispare o evento e realize cálculos. Exemplo:

using System;

class Calculator {
    public delegate void CalculationDelegate(double result);
    public event CalculationDelegate OnCalculate;

    public void Add(double a, double b) {
        double result = a + b;
        OnCalculate?.Invoke(result);
    }
}

class Program {
    static void Main() {
        Calculator calc = new Calculator();

        // Subscribe to the event
        calc.OnCalculate += result => Console.WriteLine("Result: " + result);

        calc.Add(5, 3); // Outputs: Result: 8
    }
}

`Muito bem!`


Parabéns! Você aprendeu a usar delegados e eventos para criar programas dinâmicos e orientados a eventos. Na próxima lição, exploraremos o trabalho com coleções, como listas, dicionários e filas. Vamos continuar programando!

`Perguntas Frequentes`

`A aula “Delegados e eventos” é grátis?`

Sim — o texto completo de “Delegados e eventos” é 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 6 aulas no total.

`O que vou aprender em “Delegados e eventos”?`

Aprenda como delegados e eventos permitem a comunicação entre objetos em C# 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 5 de 6.

`Quanto tempo leva a aula “Delegados e eventos”?`

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.

← AnteriorExplorando enumerações e estruturasPróximo →Trabalhando com coleções: listas, dicionários e filas

`Todas as aulas deste curso`

Introdução às interfaces
Classes abstratas
Membros e métodos estáticos
Explorando enumerações e estruturas
Delegados e eventos
Trabalhando com coleções: listas, dicionários e filas

← Voltar para C# Academy