Delegate Vs Event

 

✅ What are Delegates in C#?

A delegate is a type-safe function pointer. It holds references to one or more methods with a specific signature and return type.


✅ Why Use Delegates?

ReasonDescription
FlexibilityPass methods as parameters (i.e., callbacks).
ExtensibilityDynamically assign behavior at runtime.
DecouplingLoosely couples components.
Foundation for EventsEvents use delegates under the hood.

🟢 Delegate Example – Less Safe (Public Access)


using System;

namespace DemoDelegate
{
    // 1. Define the delegate type
    public delegate void NotifyDelegate(string name);

    public class MyDelegateClass
    {
        // 2. Public delegate field (unsafe)
        public NotifyDelegate Notify;

        public void Greet(string name)
        {
            Console.WriteLine("Hello, " + name);
        }

        public void Welcome(string name)
        {
            Console.WriteLine("Welcome, " + name);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyDelegateClass obj = new MyDelegateClass();

            // ✅ Multicast: Add multiple methods
            obj.Notify += obj.Greet;
            obj.Notify += obj.Welcome;

            // ✅ Invoke from outside
            obj.Notify("Alice");

            // ✅ Reset delegate from outside (DANGEROUS)
            obj.Notify = null;

            // ❌ Can result in NullReferenceException if not handled
            if (obj.Notify != null)
                obj.Notify("Bob");
            else
                Console.WriteLine("Delegate is null! Unsafe call prevented.");

            Console.ReadKey();
        }
    }
}

✅ What are Events in C#?

An event is a wrapper around a delegate that provides a safe mechanism for publish-subscribe communication.

  • Events are typically used in UI frameworks, real-time systems, or event-driven architectures.

  • Only the class that declares the event can raise it. Other classes can subscribe/unsubscribe but not invoke.



🟢 Event Example – Safe Encapsulation


using System;

namespace DemoEvent
{
    // 1. Define the delegate type
    public delegate void NotifyDelegate(string name);

    public class MyEventClass
    {
        // 2. Declare event based on delegate
        public event NotifyDelegate NotifyEvent;

        public void Greet(string name)
        {
            Console.WriteLine("Hello, " + name);
        }

        public void Welcome(string name)
        {
            Console.WriteLine("Welcome, " + name);
        }

        // Method to trigger the event safely from within the class
        public void TriggerEvent(string name)
        {
            // ✅ Safe check and call from inside the class
            NotifyEvent?.Invoke(name);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyEventClass obj = new MyEventClass();

            // ✅ Multicast: Add multiple methods
            obj.NotifyEvent += obj.Greet;
            obj.NotifyEvent += obj.Welcome;

            // ❌ Cannot invoke from outside the class
            // obj.NotifyEvent("Alice"); // ❌ Compilation error

            // ❌ Cannot reset to null from outside
            // obj.NotifyEvent = null; // ❌ Compilation error

            // ✅ Safe: Only class itself can invoke event
            obj.TriggerEvent("Alice");

            Console.ReadKey();
        }
    }
}


A delegate is like a method reference. You can call it directly and even modify it externally.
An event is a safer and more restricted wrapper over a delegate that enforces encapsulation, allowing only the declaring class to trigger it.

🔍 Code Mapping

FeatureDelegate Example CodeEvent Example Code
Multicast✅ Notify += Method✅ NotifyEvent += Method
Invoke from outside class✅ Notify("Alice")❌ Compile-time error
Reset from outside✅ Notify = null;❌ Compile-time error
Encapsulation / Safety❌ Can break externally✅ Invoked only inside class
Access Limited to Class❌ Publicly accessible✅ Trigger only inside class

Comments

Post a Comment

Popular posts from this blog

Interview Tips: Dot NET Framework vs Net CORE

Image
Interview Tips: Dot NET Framework vs Net CORE .NET Framework What :  It's a software development framework created by Microsoft, mainly used for building Windows applications. Why :  It has been around for a long time and is very reliable for building large, complex applications especially for enterprises. How :  You use it to build applications that run exclusively on Windows, making use of a vast array of built-in libraries and features. Why Not :  It can't be used for cross-platform applications, so if you need your application to run on other operating systems like macOS or Linux, .NET Framework isn't the right choice. .NET Core What :  It's a newer, open-source, and cross-platform framework from Microsoft, designed for modern app development. Why :  It's lightweight, high-performance, and can run on multiple operating systems (Windows, macOS, Linux). How :  You use it to build modern, scalable, and quickly deployable applications, especially cloud...
Read more

FREE Webinar: Run Your Own Independent DeepSeek LLM

Image
Faith Infotech Academy, Technopark invites you to an exclusive FREE webinar on "Run Your Own Independent DeepSeek LLM" , where you’ll learn how to deploy and manage DeepSeek LLM effectively. Speaker:  Abhilash Nelson  Trainer & Researcher in AI & Machine Learning  An expert in AI and machine learning, Abhilash will guide you through the process of setting up and running your own independent DeepSeek LLM, empowering you with insights into model deployment, fine-tuning, and real-world applications. What You’ll Learn: ✅ Understanding DeepSeek LLM and its capabilities ✅ Setting up DeepSeek LLM on your own infrastructure ✅ Fine-tuning and optimizing the model for various applications ✅ Use cases and practical demonstrations Key Takeaways: ✅ Mastering DeepSeek LLM for Developers ✅ Boost Your VS Code workflow ✅ Learn to Run DeepSeek locally for AI assistance 📅 Date: 6 February 2025, Thursday 🕒 Time:  10.00 to 11.00 AM 📍 Mode: Online (Webinar link will be shar...
Read more

Delegates and Events

1. What are Delegates in C#? Explain: Delegates are type-safe function pointers. They act as a placeholder for methods that have a specific signature (return type and parameters). Analogy: Imagine a delegate as a contract. It specifies the "shape" of the method it can hold. Any method that fits that shape (same return type and parameters) can be assigned to the delegate. Example: public delegate int MathOperation(int x, int y);  // Define a delegate // Methods that match the delegate signature public int Add(int x, int y) { return x + y; } public int Subtract(int x, int y) { return x - y; } // Use the delegate MathOperation operation = Add; // Assign the Add method to the delegate int result = operation(5, 3); // Call the method through the delegate 2. What are Events in C#? Explain: Events are a mechanism for broadcasting notifications to interested parties (subscribers). They are built upon delegates. Analogy: Imagine an event as a doorbell. When someone presses the d...
Read more