Advanced .NET Programming I 4th Lecture Pavel Ježek pavel.jezek@d3s.mff.cuni.cz Some of the slides are based on University of Linz .NET presentations. © University of Linz, Institute for System Software, 2004 published under the Microsoft Curriculum License (http://www.msdnaa.net/curriculum/license_curriculum.aspx)

Multicast Delegates A delegate variable can hold multiple values at the same time Notifier greetings; greetings = new Notifier(SayHello); greetings += new Notifier(SayGoodBye); greetings("John"); // "Hello from John" // "Good bye from John" greetings -= new Notifier(SayHello); greetings("John"); // "Good bye from John" Note If the multicast delegate is a function, the value of the last call is returned If the multicast delegate has an out parameter, the parameter of the last call is returned. ref-Parameter are passed through all methods.

Delegates Are Immutable

Delegate Variance

Generic Delegates A check method is passed, delegate bool Check<T>(T value); class Payment { public DateTime date; public int amount; } class Account { ArrayList payments = new ArrayList(); public void Add(Payment p) { payments.Add(p); } public int AmountPayed(Check<Payment> matches) { int val = 0; foreach (Payment p in payments) if (matches(p)) val += p.amount; return val; A check method is passed, which checks for every Payment, whether it is eligible bool PaymentsAfter(Payment p) { return DateTime.Compare(p.date, myDate) >= 0; } ... myDate = new DateTime(2001, 11, 9); int val = account.AmountPayed(new Check<Payment>(PaymentsAfter));

Delegate Variance

Standard Delegates public delegate void Action() ... public delegate void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3) public delegate TResult Func<TResult>() public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2) public delegate bool Predicate<T>(T obj )

Ordinary Delegates class C { int sum = 0; void SumUp(Node p) { sum += p.value; } void Print(Node p) { Console.WriteLine(p.value); } void Foo() { List list = new List(); list.ForAll(SumUp); list.ForAll(Print); } requires the declaration of a named method (SumUp, Print, ...) SumUp and Print cannot access the local variables of Foo => sum must be declared as a global field delegate void Visitor(Node p); class List { Node[] data = ...; ... public void ForAll(Visitor visit) { for (int i = 0; i < data.Length; i++) visit(data[i]); }

Anonymous Methods formal parameter code class List { ... public void ForAll(Visitor visit) { } delegate void Visitor(Node p); class C { void Foo() { List list = new List(); int sum = 0; list.ForAll(delegate (Node p) { Console.WriteLine(p.value); }); list.ForAll(delegate (Node p) { sum += p.value; }); } formal parameter code method code is specified in-place does not require the declaration of a named method anonymous method can access Foo's local variable sum return terminates the anonymous method (not the enclosing method) Restrictions anonymous methods must not have formal parameters of the kind params T[] anonymous methods must not be assigned to object anonymous methods must not access ref or out parameters of the enclosing method

Further Simplification delegate void EventHandler (object sender, EventArgs arg); Button button = new Button(); Button.Click += delegate (object sender, EventArgs arg) { Console.WriteLine("clicked"); }; Can be simplified as follows Button.Click += delegate { Console.WriteLine("clicked"); }; Formal parameters can be omitted if they are not used in the method body Restriction Formal parameters can only be omitted if the delegate type does not have out parameters

Lambda Expressions Example of C# 2.0 anonymous method: class Program { delegate T BinaryOp<T>(T x, T y); static void Method<T>(BinaryOp<T> op, T p1, T p2) { Console.WriteLine(op(p1, p2)); } static void Main() { Method(delegate(int a, int b) { return a + b; }, 1, 2); C# 3.0 lambda expressions provide further simplification: Method((a, b) => a + b, 1, 2); Pavel Ježek C# 3.0 and .NET 3.5

Lambda Expressions (2) Expression or statement body Implicitly or explicitly typed parameters Examples: x => x + 1 // Implicitly typed, expression body x => { return x + 1; } // Implicitly typed, statement body (int x) => x + 1 // Explicitly typed, expression body (int x) => { return x + 1; } // Explicitly typed, statement body (x, y) => x * y // Multiple parameters () => Console.WriteLine() // No parameters A lambda expression is a value, that does not have a type but can be implicitly converted to a compatible delegate type delegate R Func<A,R>(A arg); Func<int,int> f1 = x => x + 1; // Ok Func<int,double> f2 = x => x + 1; // Ok Func<double,int> f3 = x => x + 1; // Error – double cannot be // implicitly converted to int Pavel Ježek C# 3.0 and .NET 3.5

Lambda Expressions (3) Lambda expressions participate in inference process of type arguments of generic methods In initial phase, nothing is inferred from arguments that are lambda expressions Following the initial phase, additional inferences are made from lambda expressions using an iterative process Pavel Ježek C# 3.0 and .NET 3.5

Lambda Expressions (4) Generic extension method example: public class List<T> : IEnumerable<T>, … { … } public static class Sequence { public static IEnumerable<S> Select<T,S>( this IEnumerable<T> source, Func<T, S> selector) { foreach (T element in source) yield return selector(element); } Calling extension method with lambda expression: List<Customer> customers = GetCustomerList(); IEnumerable<string> names = customers.Select(c => c.Name); Rewriting extension method call: IEnumerable<string> names = Sequence.Select<T, S>(customers, c => c.Name); T type argument is inferred to Customer based on source argument type Sequence.Select<Customer, S>(customers, c => c.Name) c lambda expression argument type is infered to Customer Sequence.Select<Customer, S>(customers, (Customer c) => c.Name) S type argument is inferred to string based on return value type of the lambda expression Sequence.Select<Customer, string>(customers, (Customer c) => c.Name) Pavel Ježek C# 3.0 and .NET 3.5