Delegates and Events
Tom Roeder CS215 2006fa
Motivation Function Pointers
Treat functions as first-class objects eg. Scheme: (map myfunc somelist)
works because functions are lists
eg. Mathematica: {#, #^2} & /@ Range[1,10] eg. C/C++:
typedef int (*fptr)(int*); int my_method(int* var) { if (var != NULL) return *var; } fptr some_method = my_method; int take_f_param(fptr g) { int x = 10; int y = &x; return g(y); } printf(%d\n, take_f_param(some_method));
Works because functions are pointers to code
Motivation Function Pointers
Java
no equivalent way to get function pointers use inner classes that contain methods or simply use interfaces functions are not objects same problem as integers
Why not?
Comparators
Sort method on many containers
provides efficient sorting needs to be able to compare to objects
Solution: IComparer
public class ArrivalComparer: IComparer { public ArrivalComparer() {} public int Compare(object x, object y) { return ((Process)x).Arrival.CompareTo(((Process)y).Arrival); } }
Can then call
sortedList.Sort(new ArrivalComparer());
Delegates
An objectified function
inherits from System.Delegate sealed implicitly looks much like C/C++ style function pointer defines a new type: Func: takes int, returns int declared like a function with an extra keyword stores a list of methods to call
eg. delegate int Func(ref int x)
Delegates Example
delegate int Func(ref int x); int Increment(ref int x) { return x++; } int Decrement(ref int x) { return x--; } Func F1 = new Func(Increment); F1 += Decrement; x = 10; Console.WriteLine(F1(ref x)); Console.WriteLine(x);
Delegate calls methods in order
ref values updated between calls return value is the value of the last call
Delegates Usage Patterns
Declared like a function Instantiated like a reference type
takes a method parameter in the constructor can add more than one instance of a method - removes the last instance of the method in the list
Modified with +, -, +=, -=
Called like a function: functional programming
Delegates Usage Examples
delegate int Func(int x); List<int> Map(Func d, List<int> l) { List<int> newL = new List<int>(); foreach(int i in l) { newL.Add(d(l)); } return newL; }
Allows code written in a more functional style
Notes on Delegates
this pointer captured by instance delegates
thus can capture temporary objects from method calls or elsewhere in delegates eg. delegate int Func(int x); Func f = new Func(); { TempObject o = new TempObject(); f += o.m; } // o is now out of scope
Covariance & Contravariance
If the type of the return value is subclass
then the delegate is still acceptable called covariance then the delegate is likewise acceptable called contravariance
If the type of the args are subclasses
Anonymous Methods
Func f = new Func(); int y = 10; f += delegate(int x) { return x + y; }
Creates a method and adds it to delegate
treated the same as other methods good for one-time, short delegates outer variables like y in the above example
Variables captured by anonymous method
Anonymous Methods
using System; delegate void D(); class Test { static D[] F() { D[] result = new D[3]; for (int i = 0; i < 3; i++) { int x = i * 2 + 1; result[i] = delegate { Console.WriteLine(x); }; } return result; } static void Main() { foreach (D d in F()) d(); } }
Anonymous Methods
static D[] F() { D[] result = new D[3]; int x; for (int i = 0; i < 3; i++) { x = i * 2 + 1; result[i] = delegate { Console.WriteLine(x); }; } return result; }
First returns 1,3,5. Second returns 5,5,5
Outer variables are captured locations Not given values at delegate creation time
Can communicate through outer variables
Events
Special class of delegates
given the event keyword
class Room { public event EventHandler Enter; public void RegisterGuest(object source, EventArgs e) { } public static void Main(string[] args) { Enter += new EventHandler(RegisterGuest); if (Enter != null) { Enter(this, new EventArgs()); } } }
Events
Enter is an object of type delegate
when event is raised each delegate called C# allows any delegate to be attached to an event .NET requires only EventHandlers
needed for CLS compatibility
Adds restrictions to the delegate
can only raise an event in its defining class outside, can only do += and -= : return void
Events
Modifiers on events
public/private: define accessibility of += and -= events can be defined in interfaces
Delegates cannot be defined in interfaces
Since can only do += and -= outside, how do we raise events?
normally with methods: eg. Button.OnClick sole purpose is to raise the event
Events Accessors
add and remove accessors
can be explicitly defined for events use anonymous methods normally generated by compiler when want to control the space used for storage access the custom data structure in OnClick() or use to control accessibility
For example
Events - Uses
Registering callbacks
common programming paradigm examples in OS and threaded code any asynchronous code does this eg. Button.OnClick basis of Windows.Forms Handles the asynchrony of the user
Windowing code
Event-Based Programming
Style of concurrent programming
contrasts with thread based concurrency based on the number of events not on the number of processors
although limited by number of processors
events in C# could be backed by an eventbased system
full support for events already in language
Generics and Delegates
Delegates can use generic parameters:
delegate int Func<T>(T t)
allows interaction with generic classes
class Test<T> { public Test(Func<T> f, T val) { }
Is the type Func<T> open or closed?
Methods can use delegates similarly Both can add where constraints like classes
Generics and Delegates
Does the following work?
delegate int F<T>(int x); class Test2<T,U> where T : class where U : F<T> { }
no: type constraints cannot be sealed classes can, however, change F<T> to System.Delegate
then we lose some ability to statically typecheck
Homework 2 - Polynomials
Build a class that implements the polynomials
polynomials in some abstract variables and further must be generic in their scalars
only constraint: must have and + is this possible?
What should be our solution?
add methods to add, subtract, and multiply
return Polynomials of same type
add an indexer to get i-th term
Homework 3 Sets
Write a Set<T>
implements the union, intersection, and difference implements IEnumerable<T> implements a Filter methods
Questions?
