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!
