Named method vs anonymous method
A named method is a method that can be called by its name:
// named method declaration
public string Join(string s1, string s2)
{
return s1+s2;
}
// named method usage
var result = Join("this is ", "a joined string");
An anonymous method is a method that is passed as an argument to a function, without the need for its name. These methods can be constructed at runtime or be evaluated from a lambda expression.
// declaration
public void ProcessBook(Action<Book> process, List<Book> books)
{
foreach (Book b in books)
{
process(b);
}
}
// usage - print book titles
ProcessBook(bookList, book => Console.WriteLine(book.Title))
Here book => Console.WriteLine(book.Title)
is the lambda expression and it’s result is an anonymous function that will be run by the method ProcessBook
Lamdba expressions
You use a lambda expression to create an anonymous method.
We use =>
to separate the lambda’s (optional) params list from its body. It can be any this 2 forms:
// lambda expression: has an expression as its body
(input-params) => expression
// lambda statement: has a statement block as its body
(input-params) => { sequence-of-statements }
Any lambda expression can be converted to a delegate type. The types of its parameters and return value define the delegate type.
- If a lambda expression just consumes a class and it doesn’t return a value, it can be converted to
Action<T>
. (a lambda that consumes 2 classes and doesn’t return anything can be converted toAction<T1,T2>
) - If the lambda consumes a class and returns a
bool
value, it can be converted toPredicate<T>
- If it consumes a class and returns anything else, it can be converted to
Func<T,K>
lambda statement with 0 params
Action line = () => Console.WriteLine();
lambda with 1 param
Func<double, double> cube = x => x * x * x;
lambda with 2 or more params
Func<int, int, bool> testForEquality = (int x, int y) => x == y;
default values for lambdas
From c# 12 on you can provide default values for params on lambda expressions.
var incrementBy = (int source, int increment = 1) => source + increment;
Console.WriteLine(IncrementBy(5)); // 6
Console.WriteLine(IncrementBy(5, 2)); // 7
Reference(s)
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions
https://stackoverflow.com/questions/20869312/c-anonymous-method-vs-named-method