C# Version HisotryC# Language FeaturesInstalling Visual StudioC# Basic Project StructureHello Wolrd, first C# program
Variables in C# Explicitly typed variables in C#Implicitly typed variables in C#Constants in C#Data types in C#Integral data types in C#Floating-point data types in C#Comparison between Float, Double and DecimalChar data type in C#String data type in C#Boolean data type in C#DateTime data type in C#Enumeration data type in C#Array data type in C#Object data type in C#Dynamic data type in C#Anonymous data type in C#Nullable data type in C#Type casting in C#Type safety in C#Literals in C#Operators in C#Ternary Operator in C#Null coalescing Operator in C#Tilde(~) Operator in C#Keywords in C#Namespace in C#Nullable Types in C#Nullable Helper Class in C#Characteristics of Nullable typesC# Difference between "int" and "int?"
Block statement in C#Empty statement in C#Jump statements in C#Break statement in C#Continue statement in C#Difference between continue and breakGoto statement in C#Return statement in C#Throw statement in C#Yield keyword in C#Checked statement in C#Unchecked statement in C#Lock statement in C#Using statement in C#Enum/Enumeration in C#If-Else statement in C#Switch statement in C#What is a loop in C#?For loop in C#While loop in C#Do while loop in C#Foreach loop in C#Nested loop in C#Infinite loop in C#
C# Method or FunctionC# Method Parameters and ArgumentsC# Method OverloadingC# Return StatementsC# Static vs. Instance MethodsC# Method ModifiersC# Method Signatures and Naming ConventionsC# Function Documentation and CommentsC# Value Type ParametersC# Ref Type ParametersDifference between Value and Ref TypeC# Out ParametersDifference between Ref and out parametersC# Optional parametersAre Nullable types reference types in C#"
Exception Handling in C#Types of exception in C#Try catch finally in C#finally block in C#try block without catch blockMultiple catch blocks in exceptionCatch multiple exceptions in C#Base class of exception in C#finally block execution in C#finally block execution in case of errorFinally and return statementWays to use try-catch-finallyException throw from finally block"throw" and "throw ex" in C#Differene between finalize() and finallyInner exception in C#Error types in C#Catch multi exception by single catch blockUser defined/custom excetion in C#Compile and run time exception in C#Difference between "error" and "exception"System and application exception in C#Exception handling abuse in c#?
C# String BasicsC# String ManipulationC# String FormattingC# String Comparison and SearchingC# StringBuilder ClassC# Regular ExpressionsC# Unicode and EncodingC# String Parsing and ConversionDifference between "string" and "String"C# String Escape SequenceC# Mutable and Immutable ConceptProve that string is immutableString value stored in memoryDifference between string and stringbuilderOverride the tostring() method
Enum/enumeration in C#Can you inherit enum in C#?Convert enum to stringConvert enum to list in C#Cast int value to enum in C#Get int value from enum in C#Convert string to enum in C#Usage of enum in switch case statementLoop through all enum valuesUse tilde(~) with Enum
Main() method basics in C#More than one "Main()" method in C#Static Main() method in C#Overload Main() method in C#Override Main() method in C#Access modifiers of Main() method in C#Non-static method in C#Main() method arguments and return typeasync Main() method in C#Class without Main() method in C#Main() method rules in C#
Recursion in C#Base condition in recursion in C#Recursive Algorithms in C#Tree traversal using recursion in C#Stack overflow error in recursionBack tracking using recursionIndirect recursion in C#Recursive data structures in C#Tail Recursion in C#Recursive problem solvingRecursion vs Iteration
C# File and File InfoC# StreamReader and StreamWriterC# FileStream and BinaryReader/BinaryWriterC# Directory and DirectoryInfo ClassesC# File PathsC# File and Directory OperationsC# File Exceptions and Error HandlingC# File Serialization and DeserializationC# File System Watcher
What is array?Single dimension arrayMulti dimension arrayJagged arrayParam arrayArray with multi data typesDifferent data types from object arrayArray with non-default valuesArray methods and propertiesArray manipulation techniquesArray sorting algorithmsArray Searching algorithms(linear, binary search)Array finding maximum and minimumArray of Reference Types
C# GenericsC# Generic Constraints
C# ArrayListC# Array vs ArrayListC# ListC# SortedListC# DictionaryC# HashtableC# Dictionary vs HashtableC# HashSetC# Hashtable vs HashSetC# StackC# Queue
C# IEnumerableC# IEnumeratorC# ICollectionC# IListC# IDictionaryC# IDisposableC# IComparableC# IEquatableC# ICloneableC# IQueryableC# INotifyPropertyChangedC# INotifyCollectionChangedC# IFormattableC# IAsyncResultC# IComparerC# IEqualityComparerC# IHttpHandlerC# IHttpModule
C# DelegatesC# Single-Cast DelegateC# Multi-Cast DelegateC# Generic DelegatesC# Func DelegateC# Action DelegateC# Predicate DelegateC# Anonymous MethodsC# EventsDifference Between Event & DelegateDifference Between Interface & DelegateC# Covariance and Contravariance
Previous
Next

C# - Generic Delegates

A generic delegate is a delegate that has type parameters. It allows you to define the delegate type once and use it with different data types, without defining a separate delegate for each data type. This promotes code reusability and type safety.

The .NET Framework has several built-in generic delegate types, such as Func, Action, and Predicate.

1. Func:

  • Represents a delegate that can have a return type and zero or more parameters.
  • The last type parameter is always the return type.

Example:


Func<int, int, int> add = (x, y) => x + y;
Console.WriteLine(add(3, 4));  // Outputs 7

Func<string, string, string> concatenate = (a, b) => a + b;
Console.WriteLine(concatenate("Hello", " World"));  // Outputs "Hello World"

2. Action:

  • Represents a delegate that has no return (void) but can have zero or more parameters.

Example:


Action<string> displayMessage = message => Console.WriteLine(message);
displayMessage("Hello from Action!");  // Outputs "Hello from Action!"

3. Predicate:

  • Represents a delegate that takes one input parameter of type T and returns a bool. Often used for comparisons or conditions.

Example:


Predicate<int> isEven = num => num % 2 == 0;
Console.WriteLine(isEven(4));  // Outputs "True"
Console.WriteLine(isEven(7));  // Outputs "False"

Creating Custom Generic Delegates:

While the built-in generic delegates cater to many common use-cases, you can also define your own generic delegates:


public delegate T MyGenericDelegate<T>(T param1, T param2);

public class Program
{
    public static void Main()
    {
        MyGenericDelegate<int> addIntegers = (a, b) => a + b;
        Console.WriteLine(addIntegers(10, 20));  // Outputs 30

        MyGenericDelegate<string> concatenateStrings = (a, b) => a + b;
        Console.WriteLine(concatenateStrings("Hello", " World!"));  // Outputs "Hello World!"
    }
}

Conclusion:

Generic delegates in C# allow for a more versatile and reusable way to define delegate types. With the ability to parameterize the types they work with, they can reduce redundancy and improve type safety in applications. The built-in generic delegates like Func, Action, and Predicate cater to many standard use-cases and are widely used in .NET for various tasks, including LINQ operations.

Points to Remember:
  1. Type Safety: Generic delegates ensure type safety. Only methods with matching signatures can be assigned based on the provided type argument.
  2. Flexibility: They allow for delegate type definitions without commitment to a specific data type, enabling a single delegate type's use with multiple data types.
  3. Built-in Generic Delegates: C# includes built-in generic delegates like Func, Action, and Predicate. These can be used without defining custom delegates.
    • Func: Denotes a method that returns a value. The last type argument specifies the return type, and the preceding ones are input parameter types.
    • Action: Represents a method returning void with up to 16 input parameters.
    • Predicate: Denotes a method with a single input parameter of type T and returns a boolean.
  4. Type Inference: The C# compiler often infers the correct type arguments when a generic delegate is assigned, enhancing code conciseness.
  5. Varied Signatures: Depending on the number of generic type parameters and constraints, generic delegates can have diverse method signatures.
  6. Constraints: Like other generic entities, constraints can be applied to generic delegate type parameters to limit the types they can work with.
  7. Combination with Other Generic Types: Generic delegates can collaborate with generic classes, interfaces, and methods for high reusability.
  8. Legacy Support: Despite their flexibility, generic delegates are entirely interoperable with non-generic variants.
  9. Lambda Expressions: Generic delegates integrate smoothly with lambda expressions for concise, inline delegate definitions.
  10. Avoiding Repetition: Using generic delegates helps evade defining multiple delegate types that differ only in their parameter or return types.

In essence, generic delegates in C# bolster the power of standard delegates by introducing type parameterization, offering both flexibility and type safety. Being acquainted with them, particularly the built-in Func, Action, and Predicate delegates, is pivotal for modern C# developers.

Previous
Next