Advanced .NET Programming I 3rd 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)

Collection Classes .NET 1.0, 1.1 based on System.Object System.Collections namespace .NET 2.0, 3.0, 3.5, 4.0 generic classes System.Collections.Generic namespace

Interface ICollection : IEnumerable Interface ICollection<T> : IEnumerable, IEnumerable<T> Basic interface for collections: New in ICollection<T>: int Count { get; } number of elements bool IsSynchronized {get;} collection synchronised? object SyncRoot {get;} returns object for synchronisation void CopyTo(Array a, int index); copies the elements into array (starting at position index) void Add(T item); bool Remove(T item); void Clear(); bool Contains(T item);

Interface IList : ICollection, IEnumerable Interface IList<T> : ICollection<T>, IEnumerable, IEnumerable<T> Interface for object collections with a defined order interface IList { object this [ int index ] {get; set;} int Add(object value); void Insert(int index,object value); void Remove(object value); void RemoveAt(int index); void Clear(); bool Contains(object value); … }

Interface IDictionary Interface IDictionary<T, U> interface IDictionary : ICollection, IEnumerable { ICollection Keys {get;}; ICollection Values {get;}; object this[object key] {get; set;} void Add(object key, object value); void Remove(object key); bool Contains(object key); IDictionaryEnumerator GetEnumerator(); … } interface IDictionary<T, U> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, ... { public struct DictionaryEntry { public DictionaryEntry (object key, object value); public object Key {get;}; public object Value {get;}; }

Namespace System.Collections.Generic Classes List<T> SortedList<T, U> Dictionary<T, U> SortedDictionary<T, U> Stack<T> Queue<T> LinkedList<T> HashSet<T> SortedSet<T> implemented as a reallocated T[] (corresponds to ArrayList) implemented as a pair of realloc. T[], U[] (corr. to SortedList) implemented as a hash table in an array (corr. to Hashtable) implemented as a red-black tree implemented in a reallocated T[] (corresponds to Stack) implemented as a circular queue in r. T[] (corresponds to Queue) doubly linked list of LinkedListNode<T> (new in .NET 2.0) implemented as a hash table in an array + provides quick set operations (new in .NET 3.5 + implements ISet<T> in 4.0) implemented as a red-black tree (new in .NET 4.0) Interfaces ICollection<T> IList<T> IDictionary<T, U> ISet<T> IEnumerable<T> IEnumerator<T> IComparable<T> IComparer<T> IEquatable<T> IEqualityComparer<T> (new in .NET 4.0)

Type Variance

Any Meaningful Application of the Type Below? struct X<T> where T : class { private T t; public static implicit operator T(X<T> x) { return x.t;  } public static implicit operator X<T>(T t) { X<T> x; x.t = t; return x;

Sorting: IComparable and IComparer IComparable is interface for types with order classes implementing IComparable are values types like Int32, Double, DateTime, … class Enum as base class of all enumeration types class String IComparer is interface for the realization of compare operators public interface IComparable { int CompareTo(object obj); // <0 if this < obj, 0 if this == obj, >0 if this > obj } public interface IComparable<in T> { int CompareTo(T obj); // <0 if this < obj, 0 if this == obj, >0 if this > obj public interface IComparer { int Compare(object x, object y); // <0 if x < y, 0 if x == y, >0 if x > y } public interface IComparer<in T> { int Compare(T x, T y); // <0 if x < y, 0 if x == y, >0 if x > y

IEnumerable and IEnumerator (1) Anything which is enumerable is represented by interface IEnumerable IEnumerator realizes an iterator Also generic versions IEnumerable<out T> and IEnumerator<out T> Enumerator should throw an InvalidOperationException on concurrent modification! interface IEnumerable { IEnumerator GetEnumerator(); } interface IEnumerator { object Current {get;} bool MoveNext(); void Reset(); }

CLI Type Inheritance pointers (C#: Type *) System.Object (C# keyword: object) interfaces (C# keyword: interface) System.String (C# keyword: string) System.Array System.Delegate arrays (C#: Type[] or Type[,]) System.MulticastDelegate System.ValueType delegates (C# keyword: delegate) user-defined classes (C# keyword: class) simple types System.Int32 (C# keyword: int) System.Double (C# keyword: double) System.Int64 (C# keyword: long) System.Enum System.Nullable (C#: Type?) user-defined structures (C# keyword: struct) System.Boolean (C# keyword: bool) enumerations (C# keyword: enum) …

Delegate = Method Type Declaration of a delegate type delegate void Notifier (string sender); // ordinary method signature // with the keyword delegate Declaration of a delegate variable Notifier greetings; Assigning a method to a delegate variable void SayHello(string sender) { Console.WriteLine("Hello from " + sender); } greetings = new Notifier(SayHello); Calling a delegate variable greetings("John"); // invokes SayHello("John") => "Hello from John"

Assigning Different Methods Every matching method can be assigned to a delegate variable void SayGoodBye(string sender) { Console.WriteLine("Good bye from " + sender); } greetings = new Notifier(SayGoodBye); greetings("John"); // SayGoodBye("John") => "Good bye from John" Note A delegate variable can have the value null (no method assigned). If null, a delegate variable must not be called (otherwise exception). Delegate variables are first class objects: can be stored in a data structure, passed as a parameter, etc.

Creating a Delegate Value new DelegateType (obj.Method) A delegate variable stores a method and its receiver, but no parameters ! new Notifier(myObj.SayHello); obj can be this (and can be omitted) new Notifier(SayHello); Method can be static. In this case the class name must be specified instead of obj. new Notifier(MyClass.StaticSayHello); Method signature must match the signature of DelegateType - same number of parameters - same parameter types (including the return type) - same parameter kinds (ref, out, value)

Simplified Creation of Delegates delegate void Printer(string s); void Foo(string s) { Console.WriteLine(s); } Printer print; print = new Printer(this.Foo); print = this.Foo; print = Foo; simplified form: delegate type is infered from the type of the left-hand side delegate double Function(double x); double Foo(double x) { return x * x; } Printer print = Foo; Function square = Foo; assigns Foo(string s) assigns Foo(double x) overloading is resolved using the type of the left-hand side