1. Windows Programming Using C# Arrays, Collections

2. 2 Contents Arrays Collections Generics Strings

3. 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. 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. 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. 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. 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. 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. 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. 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. 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. 12 Indexers An indexer with integer indices public int this[int index] { get { return data[index]; } set { data[index] = value; } }

13. 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. 14 Contents Arrays Collections Generics Strings

15. 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. 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. 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. 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. 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. 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. 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. 22 ArrayList Methods Method/PropertyDescription CapacityThe number of elements the list can hold Item()Indexer Add()Add an object to the ArrayList AddRange()Add the elements of a collection to the end of the array BinarySearch()Binary search Clear()Removes all elements from the ArrayList Clone()Creates a shallow copy Contains()Determines if a value is in the ArrayList CopyTo()Copies to a 1-D array

23. 23 ArrayList Methods Method/PropertyDescription GetEnumerator()Returns an enumerator GetRange()Copies a range to a new ArrayList IndexOf()Returns the index of the first occurrence of a value InsertRange()Inserts elements from a collection Remove()Removes the first occurrence of an element RemoveAt()Removes the element as a specific location Sort()Sorts the ArrayList ToArray()Copies the elements to a new array TrimToSize()Sets capacity to current size

24. 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. 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. 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. 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. 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. 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. 30 Queue Class MethodDescription Enqueue(object)Adds an object to the queue object Dequeue()Takes an object off the queue and returns it. Throws InvalidOperationException if empty. object Peek()Returns object at head of queue without removing it. object[] ToArray()Returns contents as an array. Implements: ICollection, IComparable, ICloneable

31. 31 Stack Class MethodDescription Push(object)Adds an object to the stack object Pop()Takes an object off the stack and returns it. Throws InvalidOperationException if empty. object Peek()Returns object at top of stack without removing it. object[] ToArray()Returns contents as an array. Implements: ICollection, IComparable, ICloneable

32. 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. 33 IDictionary Interface Method/PropertyDescription Add(object key, object value)Adds a key and value to the collection Remove(object key)Removes the key and value pair bool Contains(object key)True if the dictionary contains the key IDictionaryEnumerator GetEnumerator() Returns an enumerator object this[object key]Gets or sets item with specified key. If the key does not exist, it is created. ICollection ValuesReturns the values as a collection ICollection KeysReturns the keys as a collection

34. 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. 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. 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. 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. 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. 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. 40 Contents Arrays Collections Generics Strings

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

46. 46 Creating Generic Class Instances To create an instance of our generic array for integers GenericArray iar = new GenericArray (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. 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. 48 Generic Methods static void test (string id, GenericArray 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. 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. 50 Generic Collections Generic ClassDescription Dictionary Generic unordered dictionary LinkedList Generic doubly linked list List Generic ArrayList Queue Generic queue SortedDictionary Generic dictionary implemented as a tree so that elements are stored in order of the keys SortedList Generic binary tree implementation of a list. Can have any type of subscript. More efficient than SortedDictionary in some cases. Stack Generic stack

51. 51 Contents Arrays Collections Generics Strings

52. 52 Strings C# strings are really instances of System.String The class implements  IComparable, ICloneable, IConvertable, IEnumerable, IEnumerable, IComparable, IEquatable The class provides a large number of methods for manipulating strings

53. 53 Creating Strings The easiest way is to assign a string in quotes string s = “abc”; All builtin types have a ToString() method which can be used to convert to a string int n = 5; string s1 = n.ToString(); Verbatim strings start with an @ symbol and do not have escape characters replaced  string exact = @”ab\nc”

54. 54 Manipulating String Contents Strings are immutable This means that any attempt to change a string will create a new string This has major performance implications If you will be making major changes to a string, you should use a StringBuilder

55. 55 Accessing String Contents Strings have an indexer which supports get only String s = “abc”; Console.WriteLine(s[1]); There is also a substring method Substring(int startIdx); Substring(int start, int len); Find the string length with Length property Length

56. 56 Comparing Strings A static method to compare two strings  static int compare(string, string); An instance method to compare this to another string  int CompareTo(string); Static & instance versions of Equals  int Equals(string)  static bool Equals(string, string)

57. 57 Comparing Strings  Comparing the starts and ends of strings bool startsWith(string) bool endsWith(string)

58. 58 Searching Strings To find the first index of a char  int IndexOf(char)  int IndexOf(char, int startIndex) To find the first index of a string  int IndexOf(string)  int IndexOf(string, int startIndex) To find the last index of a char  int LastIndexOf(char)  int LastIndexOf(char, int startIndex) To find the last index of a string  int LastIndexOf(string)  int LastIndexOf(string, int startIndex)

59. 59 Searching Strings Find the first occurrence of any of a set of characters  int IndexOfAny(char[])  int IndexOfAny(char[], int startIndex) Find the last occurrence of any of a set of characters  int LastIndexOfAny(char[])  int LastIndexOfAny(char[], int startIndex)

60. 60 Handling Spaces To remove a set of chars from start or end  TrimStart(chars[])  TrimEnd(chars[]) To remove spaces from both ends  Trim() To remove a set of chars from both ends  Trim(char[]) To pad spaces on either side  PadRight(int totalLength)  PadLeft(int totalLength)

61. 61 Converting Case ToUpper() ToLower()

62. 62 Splitting and Joining To split a string into an array of strings at every occurrence of a separator char  string[] split(string, char[]) To join an array of strings into one string with a separator string between every pair of string  string join(string sep, string[])

63. 63 Formatting To format an object into a string  string format(string fmt, object) The format string is the same as used by WriteLine where an argument is referenced by an index  string s = s1.format(“{0:fmt}”, i);  Where fmt is one of the format codes on the next page

64. 64 Formatting FormatMeaning CCurrency DDecimal FFixed point EScientific PPercent XHexadecimal DLong date

65. 65 StringBuilder Class The trouble with strings is that they are immutable Every time you have to concatenate two strings, a new string is produced This creates a huge amount of memory allocation and garbage collection The StringBuilder is a class which can build a string much more efficiently

66. 66 StringBuilder Class To create one StringBuilder() StringBuilder(int capacity) If the capacity of the StringBuilder is exceeded, new space is automatically allocated Ensuring sufficient capacity at the start is more efficient than forcing reallocation

67. 67 Appending to a StringBuilder StringBuilder Append(anyPrimitive)  This produces a string representation of the primitive and appends it onto the end of the contents of the StringBuilder  This can be used to append strings too You can also append a formatted string similar to the formatting done by WriteLine sb.AppendFormat("2) {0}, {1}", var1, var2);

68. 68 Appending to a StringBuilder You can also append a line using the default line terminator AppendLine() AppendLine(string) Without a parameter, it just inserts a line terminator With a parameter, the string is appended followed by the line terminator

69. 69 Getting the Content Building a string is useless unless you can retrieve it To get the whole StringBuffer string ToString() To get just part of the StringBuffer string ToString(int start, int len)