PricingLoginStart free
C# Academy · Lesson

Delegates and Events

Learn how delegates and events enable communication between objects in C#.

Lesson 5 of 610 steps

Delegates and Events is a free C# Academy lesson on CoddyKit. This is lesson 5 of 6. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the C# Academy learning path, and your progress syncs across the web and the CoddyKit app. The C# Academy course includes 6 lessons in total.

Delegates and Events

Welcome to the next lesson! In this lesson, you’ll learn about delegates and events in C#, their purpose, and how they enable event-driven programming. Let’s get started!

Delegates and Events — illustration 1

What is a Delegate?

A delegate is a type that represents a reference to a method. It allows methods to be passed as parameters and invoked dynamically.

Key Point: Delegates are essential for implementing events and callback functions in C#.

Defining and Using Delegates

To define a delegate, use the delegate keyword. Example:

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

Multicast Delegates

A single delegate can point to multiple methods, and all methods will be invoked in order. Example:

Tip: Use multicast delegates for scenarios where multiple actions need to be performed.

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

What is an Event?

An event is a mechanism that allows a class to notify other classes or objects when something of interest occurs. Events are built on top of delegates.

Key Point: Events enable loose coupling between publishers and subscribers in event-driven programming.

Defining and Using Events

To define an event, use the event keyword with a delegate type. Example:

Key Point: Events allow you to build reactive and event-driven systems.

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

Unsubscribing from Events

Subscribers can unsubscribe from events using the -=` operator. Example:

Tip: Always unsubscribe from events to avoid memory leaks.

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

Practice Challenge

Create a delegate CalculationDelegate for arithmetic operations, and an event OnCalculate. Write a program that raises the event and performs calculations. Example:

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

Great Job!

Congratulations! You’ve learned how to use delegates and events to build dynamic and event-driven programs. In the next lesson, we’ll explore working with collections like lists, dictionaries, and queues. Let’s keep coding!

Delegates and Events — illustration 10
Free to start

Learn C# with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses
93
Lessons
346
Start learning freeView the full course

Frequently Asked Questions

Is the “Delegates and Events” lesson free?

Yes — the full text of “Delegates and Events” is free to read here on the web. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the C# Academy course, upgrade to CoddyKit PRO. The C# Academy course includes 6 lessons in total.

What will I learn in “Delegates and Events”?

Learn how delegates and events enable communication between objects in C#. You practise C# Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start C# Academy?

No prior experience is required. C# Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 5 of 6.

How long does the “Delegates and Events” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this C# Academy lesson?

Yes. Every C# Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Introduction to Interfaces
  2. Abstract Classes
  3. Static Members and Methods
  4. Exploring Enums and Structs
  5. Delegates and Events
  6. Working with Collections: Lists, Dictionaries, and Queues
← Back to C# Academy