leafMan illustration
Updated on March 26, 2025

Built-in Delegates in C# – Easy Explanation with Examples

Introduction

Tired of writing long delegate definitions? 😵 Wish there was an easier way to use delegates in C#? Well, you’re in luck! 🎉

C# provides Built-in Delegates, which make life so much easier. You don’t need to declare custom delegates anymore. Just use the ready-made ones and save time!

By the end of this lesson, you’ll be a pro at using Built-in Delegates in C# with real-world examples! Let’s go! 🚀

What Are Built-in Delegates in C#?

A delegate is just a reference to a method. But declaring delegates every time is boring. 😴

That’s why C# gives us three built-in delegates:

➡️ Action → For methods that don’t return a value.
➡️ Func → For methods that return a value.
➡️ Predicate → For methods that return bool.

No need to write delegate definitions anymore! Just use these ready-made ones! 🥳

Syntax of Built-in Delegates in C#

				
					Action<int> myAction;      // Stores a method with 1 int parameter, returns nothing
Func<int, string> myFunc;  // Stores a method with 1 int parameter, returns a string
Predicate<int> myPredicate; // Stores a method with 1 int parameter, returns bool

Example 1: Using Action Delegate

👉 Use Action<T> when you don’t need a return value.

💡 Think of Action<T> like a messenger. It takes input, performs an action, but doesn’t return anything.

				
					using System;

class Program {
    static void PrintMessage(string msg) {
        Console.WriteLine(msg);
    }

    static void Main() {
        Action<string> action = PrintMessage; // Using Action delegate
        action("Hello from Action delegate!"); 
    }
}

📝 Output:

				
					Hello from Action delegate!

🔎 Step-by-Step Explanation:

  1. Step 1: Declared an Action<string> delegate, which means it stores a method that takes a string and returns void.
  2. Step 2: Assigned the PrintMessage method to the action delegate.
  3. Step 3: Called action("Hello..."), which executed PrintMessage().

👉 Result? The message got printed! 🎉

 

📌 Why Use Action<T>?

✅ No need to define custom delegates. Saves time! ⏳
✅ Makes code reusable. Just assign different methods when needed! 🔄
✅ Perfect for logging, printing messages, notifications, etc. 📢

 

📌 Real-World Use Case?

Imagine a notification system where Action<string> is used to send alerts via Email, SMS, or Push Notification dynamically! 🚀

Example 2: Using Func Delegate

👉 Use Func<T, TResult> when you need a return value.

💡 Think of Func<T, TResult> like a calculator. It takes input, performs a calculation, and returns a result.

				
					using System;

class Program {
    static int DoubleNumber(int num) {
        return num * 2;
    }

    static void Main() {
        // ✅ Func delegate: Takes an int, returns an int
        Func<int, int> func = DoubleNumber;  
        
        // ✅ Calling the delegate and storing the result
        int result = func(10);  

        Console.WriteLine("Double of 10 is: " + result);
    }
}

📝 Output:

				
					Double of 10 is: 20

🔎 Step-by-Step Explanation:

  1. Step 1: Declared a Func<int, int> delegate, which means it takes an int as input and returns an int as output.
  2. Step 2: Assigned the DoubleNumber method to the func delegate.
  3. Step 3: Called func(10), which executed DoubleNumber(10) and returned 20.
  4. Step 4: Printed the result.

👉 Result? The number got doubled! 🎉

 

📌 Why Use Func<T, TResult>?

✅ Eliminates the need for custom delegates. Saves time! ⏳
✅ Perfect for mathematical operations, data transformations, filtering, etc. 🔢
✅ Enhances code reusability & readability! 📖

 

📌 Real-World Use Case?

Imagine a discount calculator where Func<decimal, decimal> is used to calculate the final price after applying a discount dynamically! 🚀

Example 3: Using Predicate Delegate

👉 Use Predicate<T> when you need a bool return value.

💡 Think of Predicate<T> like a security check. It takes input, evaluates a condition, and returns true or false.

				
					using System;

class Program {
    static bool IsEven(int num) {
        return num % 2 == 0;
    }

    static void Main() {
        Predicate<int> predicate = IsEven; // Using Predicate delegate
        bool result = predicate(10);
        Console.WriteLine("Is 10 even? " + result);
    }
}

📝 Output:

				
					Is 10 even? True

🔎 Step-by-Step Explanation:

  1. Step 1: Declared a Predicate<int> delegate, which means it takes an int as input and returns a bool as output.
  2. Step 2: Assigned the IsEven method to the predicate delegate.
  3. Step 3: Called predicate(10), which executed IsEven(10) and returned true.
  4. Step 4: Printed the result.

👉 Result? It correctly identified that 10 is even! 🎉

 

📌 Why Use Predicate<T>?

✅ Perfect for filtering data based on conditions!
✅ Commonly used in List<T>.Find() and LINQ queries.
✅ Enhances code reusability & readability!

 

📌 Real-World Use Case?

Imagine a student grading system where Predicate<int> is used to check if a student has passed or failed based on a minimum score! 🚀

Why Are Built-in Delegates Important?

✔ They save time! No need to declare custom delegates.
✔ They make code cleaner! Just use Action, Func, or Predicate.
✔ They work well with LINQ and collections!

Real-World Example: Filtering a List 📝

Imagine you have a list of numbers, and you want to filter only even numbers. You can use Predicate<int> instead of writing long loops!

				
					using System;
using System.Collections.Generic;

class Program {
    static bool IsEven(int num) {
        return num % 2 == 0;
    }

    static void Main() {
        List<int> numbers = new List<int> {1, 2, 3, 4, 5, 6, 7, 8};
        
        List<int> evenNumbers = numbers.FindAll(IsEven);  // Using Predicate

        Console.WriteLine("Even numbers: " + string.Join(", ", evenNumbers));
    }
}

📝 Output:

				
					Even numbers: 2, 4, 6, 8

🔎 Explanation:

✔ FindAll(IsEven) filters only even numbers.
✔ No need to write long loops! 🚀

Another Example: Logging Messages 📜

Use Action<string> to log messages without repeating code!

				
					using System;

class Logger {
    public static void Log(string message) {
        Console.WriteLine("[LOG]: " + message);
    }
}

class Program {
    static void Main() {
        Action<string> logAction = Logger.Log; // Using Action delegate

        logAction("Application started!");
        logAction("User logged in.");
    }
}

📝 Output:

				
					[LOG]: Application started!
[LOG]: User logged in.

🔎 Explanation:

✔ Action<string> stores the Log() method.
✔ The same delegate is reused for logging different messages.

Conclusion

Built-in Delegates in C# make coding simple and efficient.

➡️ Use Action<T> when no return value is needed.
➡️ Use Func<T, TResult> when a return value is needed.
➡️ Use Predicate<T> when returning bool.

Now go ahead and try them in your projects! Happy coding! 🎉

 

Next What?

Woohoo! 🎉 Now you know Built-in Delegates in C# like a pro! 🚀

👉 Next, you will learn about OOPs – Properties and Indexers in C#! Stay excited! 🚀

← Events in C#
C# Generics →

Leave a Comment

Share this Doc

Built-in Delegates

Or copy link