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 You Are Going to Learn in This Lesson?
✔️ What are Built-in Delegates in C#?
✔️ Why do we need them?
✔️ How to use Action, Func, and Predicate?
✔️ Real-world scenario example
✔️ Multiple coding examples
✔️ Step-by-step explanation with output
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:
- Step 1: Declared an
Action<string>delegate, which means it stores a method that takes astringand returnsvoid. - Step 2: Assigned the
PrintMessagemethod to theactiondelegate. - Step 3: Called
action("Hello..."), which executedPrintMessage().
👉 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:
- Step 1: Declared a
Func<int, int>delegate, which means it takes anintas input and returns anintas output. - Step 2: Assigned the
DoubleNumbermethod to thefuncdelegate. - Step 3: Called
func(10), which executedDoubleNumber(10)and returned20. - 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:
- Step 1: Declared a
Predicate<int>delegate, which means it takes anintas input and returns aboolas output. - Step 2: Assigned the
IsEvenmethod to thepredicatedelegate. - Step 3: Called
predicate(10), which executedIsEven(10)and returnedtrue. - 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! 🚀
