Windows Programming Using C#

1. Windows Programming Using C# Arrays, Collections

2. Contents • Arrays • Collections • Generics • Strings

3. Arrays • Arrays are similar to Java • int[] intArray; • Creates a reference to an array • intArray = new int[5]; • Creates an array object and assigns it • Array objects are reference types created on the heap • The integers in the array are value types • Array indexing is zero based

4. System.Array • All arrays are derived from this class • Properties • Length – number of elements in all dimensions • Rank – number of dimensions • Methods • BinarySearch – performs a binary search for a member

5. System.Array • Clear – sets a range of elements to 0 or null • Clone – creates a shallow copy • Copy – copies elements from one array to another • getLength – returns the length of a single dimension • IndexOf – returns the first occurrence of a value • Sort – sorts the array

6. Arrays of Objects • When you create an array of objects, it is simply an array of references to objects, not the actual objects • These references are initialized to null • You must then create objects and assign to each member of the array

7. The foreach Statement • This iterates through all elements of an array or collection • foreach (type ident in expression) statement int[] ar = new int[5] {1,2,3,4,5}; foreach(int i in ar) { Console.WriteLine(i); }

8. Rectangular Arrays • C# supports rectangular and jagged arrays • Arrays can be of 1 or more dimensions • To declare a rectangular array int[,] int2d = new int[2,3]; for (int i = 0; I < 2; i++) { for(int j = 0; j < 3; j++) { int2d[i,j] = i+j; } }

9. Jagged Arrays • These are really arrays of arrays • Each member must be created as a separate array • Note the difference in subscripting int jag[][] = new int[2][]; jag[0] = new int[5]; jag[1] = new int[10]; jag[0][1] = 15;

10. Indexers • Indexers allow any class to be indexed like an array • Indexers are declared in a way similar to properties • They always use the keyword this • The index can be an integer or even a string • * see IndexedArray

11. Indexers • Create a simple array which can be indexed • By an integer • By a string using “first”, “middle” or “last” class IndexedArray { int[] data; public IndexedArray(int sz) { data = new int[sz]; } …

12. Indexers • An indexer with integer indices public int this[int index]{ get { return data[index]; } set { data[index] = value; } }

13. Indexers • An indexer with string indices public int this[string index] { get { int idx = 0; switch (index){ case "middle": idx = data.Length / 2; break; case "first": idx = 0; break; case "last": idx = data.Length - 1; break; } return data[idx]; } }

14. Contents • Arrays • Collections • Generics • Strings

15. Collections • Collections are generic data structures for containing objects or primitives • These are often in the form of common data structures like lists, and dictionaries • Many of the collections have interfaces representing their functionality

16. The IEnumerable Interface • This states that the class supports an enumerator or iterator which steps through the elements one-by-one • Classes which implement this interface can be used with the foreach statement public interface IEnumerable { IEnumerator GetEnumerator(); }

17. The IEnumerator Interface • This is the interface the enumerator must implement • It is usually implemented as a private class within the class being enumerated public interface IEnumerator { bool MoveNext(); bool Reset(); object Current { get; } }

18. IndexedArrayEnumerator private class IndexedArrayEnumerator: IEnumerator { int idx; IndexedArray theArray; public IndexedArrayEnumerator(IndexedArray ar) { theArray = ar; idx = -1; } public bool MoveNext() { idx++; if(idx >= theArray.data.Length) return false; else return true; } public void Reset() { idx = -1; } public object Current { get{ return theArray[idx]; } } }

19. Getting an Enumerator public IEnumerator GetEnumerator() { return new IndexedArrayEnumerator(this); } • This creates and returns an enumerator • Using a separate enumerator class allows several enumerators to operate at the same time

20. The ICollection Interface • Defines properties and methods for all collections • Implements: IEnumerable • Count • the number of elements in the collection • CopyTo(Array ar, int idx) • Copies all elements to an array starting at the index

21. ArrayLists • The problem with arrays is their fixed size • ArrayLists fix this by resizing the array when the addition of new members exceeds the capacity • The class has an extensive set of methods

22. ArrayList Methods

23. ArrayList Methods

24. Sorting • Sorting primitives is easy since comparing one to another is well-defined • Sorting user-defined types is more difficult since you do not know how to compare one to another • There are two solutions • IComparable • IComparer

25. The IComparable Interface • This require one method CompareTo which returns • -1 if the first value is less than the second • 0 if the values are equal • 1 if the first value is greater than the second • This is a member of the class and compares this to an instance passed as a parameter public interface IComparable { int CompareTo(object obj) }

26. The IComparer Interface • This is similar to IComparable but is designed to be implemented in a class outside the class whose instances are being compared • Compare() works just like CompareTo() public interface IComparer { int Compare(object o1, object o2); }

27. Sorting an ArrayList • To use CompareTo() of IComparable • ArrayList.Sort() • To use a custom comparer object • ArrayList.Sort(IComparer cmp) • To sort a range • ArrayList.Sort(int start, int len, IComparer cmp)

28. Implementing IComparer • To sort people based on age class PersonComparer: IComparer { public int Compare(object o1, object o2) { PersonBase p1 = (PersonBase)o1; PersonBase p2 = (PersonBase)o2; return p1.Age.CompareTo(p2.Age); } }

29. ICloneable Interface • This guarantees that a class can be cloned • The Clone method can be implemented to make a shallow or deep clone public interface ICloneable { object Clone(); }

30. Queue Class • Implements: ICollection, IComparable, ICloneable

31. Stack Class • Implements: ICollection, IComparable, ICloneable

32. IDictionary Interface • A dictionary is an associative array • It associates a key with a value and allows a value to be retrieved by providing the key • Implements: ICollection, IEnumerable

33. IDictionary Interface

34. Hashtables • The hashtable is a common implementation of the IDictionary interface • If the key is not an integer then the hashcode for the key is used as an index into the hashtable • Keys used with hashtables must have unique hashcode for every value

35. IDictionaryEnumerator Interface • This is the type of enumerator used with dictionaries • It implements IEnumerator • Has properties • Key • Returns the key for the item • Value • Returns the value for the item

36. BitArray Class • Long bit strings can be difficult to store efficiently • Since data structures can be addressed on the byte level, we end up storing one bit per byte, wasting 7 bits • The BitArray class stores the bits efficiently while providing access

37. BitArray Class • The constructor is overloaded • BitArray(Boolean[]) • Makes a BitArray from an array of Booleans • BitArray(Byte[]) • Makes an array from an array of Bytes where each byte represents 8 bits • BitArray(int len) • Creates a BitArray of len bytes • BitArray(int[]) • Makes a BitArray from the 32 bits in each int in an array of ints

38. BitArray Indexer • The BitArray has an indexer providing both get and set BitSet bs = new BitSet(8); bs[0] = true; Console.WriteLine(bs[1]); • There are also Get and Set methods bool Get(int index) void Set(int index, bool value)

39. BitArray Operations • Various Boolean operations are provided • BitArray And(BitArray) • BitArray Or(BitArray) • BitArray Xor(BitArray) • BitArray Not() • You can set all of the bits at once • void SetAll(bool value)

40. Contents • Arrays • Collections • Generics • Strings

41. Generics • All of the containers so far have stored data as objects • This means • Containers hold any type • Operations must test the type before operating on the objects in the container • When objects are removed from the container they must be cast to their true type • The programmer must remember the type of the object placed in the container • CLR must test to see that the cast is legal

42. Generics • All of this • Places an extra burden on the programmer having to remember the types • Introduces new potential sources of error • Forces expensive run-time type checking • What is needed is a way to make a class work with many types but • Do so efficiently • Enforce compile type strong type checking

43. Generics • The solution is generics! • This is almost the same as the template facility of C++ • Classes and methods are parameterized with a type • Every time the class or method is used with a new type, the compiler generates the code for that type and compiles it • This allows strong type checking at compile time

44. Generic Classes • To create a generic class, we parameterize it with one or more type parameters • The parameter types can then be used as types within the class and will be replaced with the actual types used when the class instance is created

45. Generic Array • A growable array which can hold any type class GenericArray<T> { T[] data; public GenericArray(int sz) { if (sz < 1) sz = 1; data = new T[sz]; } … } • * see GenericArray

46. Creating Generic Class Instances • To create an instance of our generic array for integers GenericArray<int> iar = new GenericArray<int>(5); • This will cause the compiler to write a new class and replace every occurrence of the parameter T by int and compile this new class

47. Generic Methods • A class can also have generic methods which can work with any type • We will demonstrate this by writing a method to test the Generic Array • This method will be placed in the class containing the Main method

48. Generic Methods static void test<E>(string id, GenericArray<E> ar, E[] data) { for (int i = 0; i < data.Length; i++){ ar[i] = data[i]; } for (int i = 0; i < data.Length; i++){ Console.WriteLine("{0}[{1}] = {2}", id, i, ar[i]); } Console.WriteLine("final capacity={0}", ar.Capacity); }

49. Generic Collections • There are actually three different namespaces for collections • System.Collections • Non-generic collections with data stored as objects • System.Collections.Generic • Generic collections • System.Collections.Specialized • Specialized, strongly typed collections designed to work efficiently with specific types

50. Generic Collections