Cool Generic Delegates in C#

Here are some cool generic delegates (.NET 3.5) I find useful in my day to day coding.

• Action Delegate
  • Action
  • Action(T)
  • Action(T1, T2)
  • Action(T1, T2, T3)
  • Action(T1, T2, T3, T4)
• Predicate Delegate
  • Predicate<T>(T obj)
• Func Delegate
  • Func<T, TResult>
  • Func<T1, T2, T3, T4, TResult>
  • Func<T1, T2, T3, TResult>
  • Func<T1, T2, TResult>
  • Func<TResult>

ACTION DELEGATE

The Action delegate encapsulates a method that has no return value and accepts up to four parameters. Action alone represents no parameter, Action(T), Action(T1, T2) etc… represents the number of parameters.

Simple example: using Action to replace Console.WriteLine, because Console.WriteLine accepts a single string parameter, we can simply assign it to the Action<string> and call action(“ABC”) which is equivalent to the Console.WriteLine(“ABC”)

static void Main(string[] args)
{
    Action<string> action = Console.WriteLine;
    action("ABC");
    Console.ReadLine();
}

Or you can pass the action as a parameter and use it as such, using lambda, which will print “stringA1” to the console:

static void Main(string[] args)
{
    DoSomething((s, n) =>
    {
        Console.WriteLine(s + n);
    });
    Console.ReadLine();
}
 
private static void DoSomething(Action<string, int> action)
{
    string rawString = "stringA";
    int rawNumber = 1;
    action(rawString, rawNumber);
}

PREDICATE DELEGATE

The Predicate(T) delegate encapsulates a method that returns a Boolean value and accepts a single parameter.

A simple example:

static void Main(string[] args)
{
    Predicate<byte> predicate = bit =>
    {
        return bit == 1 ? true : false;
    };
 
    // This will return true
    Console.WriteLine(predicate(1));
    // This will return false
    Console.WriteLine(predicate(0));
 
    Console.ReadLine();
}

In fact, most LINQ Queries uses this predicate delegate, one simple example is the .Find method:

static void Main(string[] args)
{
    var list = new List<string>()
    {
        "a",
        "b"
    };
    string a = list.Find(i => i == "a");
    Console.WriteLine(a);
    Console.ReadLine();
}

Another useful usage is in LINQ statements like so:

    var list = new List<int>()
    {
        1,
        2
    };
 
    Predicate<int> p = val => val == 1;
 
    var i = from item in list
            where p(item)
            select item;

FUNC DELEGATE

The Func delegate is the most powerful of the lot. A Func can return any type (TResult) and accepts zero or up to four input parameters.

    var list = new List<string>
    {
        "one",
        "two",
        "three"
    };
    // This indicates a return type of boolean, and accepts
    // two input parameters of IEnumerable<string> and string
    // respectively.
    Func<IEnumerable<string>, string, bool>
        funcPredicate = (collection, item) =>
        {
            if (collection != null && collection.Count() > 6)
            {
                return collection.Contains("one");
            }
            return false;
        };
 
    var i = from item in list
            where funcPredicate (list, item)
            select item;

There you have it, the useful delegates you will definitely find handy!

Other delegates I will cover in a later post will include Expression<T>, EventHandler<TEventArgs>, Converter<TInput, TOutput> and Comparison<T>.

Have fun coding!