Module 10 - More About Classes

Module 10: More About Classes By SRIRAM . B

Overview 

Collections



Indexers



Delegates



Operator Overloading

Collections 

Collections are objects that can contain arrays of other objects and contain functionality that controls access to these objects.



Collection classes are generally used for maintains list of objects and may expose additional functionality over arrays.



This functionality comes through implementing interfaces from System.Collections namespace.

Collections.. 

There are number of interfaces in System.Collections namespace that provide basic collection functionality :

IEnumerable – Provides the capability to loop through items of collection.



ICollection – Provides ability to obtain the number of items in a collection, and to copy in simple array type.



IList – Provides list of items for collection as well as capability for accessing these elements.

Types of Collections Stack -> L I F O Queue -> F I F O ArrayList -> Array is whose size can increase and decrease dynamically. It can hold items of different types. It can increase and decrease size dynamically you don't have to use REDIM keyword . You can access any item in array using the INDEX value of the array position. Hashtable -> You can access array using INDEX value of array, but how many times you know the real value of index. Hashtable provides way of accessing the index using a user identified KEY value, thus removing the INDEX problem. SortedArrayList ->It works like Arraylist in the sorted manner.

Collection Methods 

ArrayList Argument :– ArrayList( ), ArrayList(int) – Methods :– Count – Gets the number of elements actually contained in the list – Add(Object) – Adds to the end of the list – Clear() – Removes all elements – Insert(int index, Object) – Remove(Object) – removes first occurrence of the object – GetEnumerator() returns IEnumerator » -> Use MoveNext method and current property

Collection Methods 

Stack – Push, pop, peek



Queue – Enqueue, Dequeue, peek



Hashtable – Key-value pairs – Add(Object, Object) – Key and value – Clear – removes all elements – Remove(Object) – removes the element with the specified key – GetEnumerator – returns IDictionaryEnumerator » MoveNext, Key, Value

Example – Stack Collection using System; using System.Collections; namespace Collections { class sampleStack { static void Main(string[] args) { Stack numbers = new Stack(); // fill the stack foreach (int number in new int[4] { 9, 3, 7, 2 }) { numbers.Push(number); Console.WriteLine(number + " has been pushed on the stack"); }

Example – Stack Collection.. // iterate through the stack foreach (int number in numbers) { Console.WriteLine(number); } // empty the stack while (numbers.Count != 0) { int number = (int)numbers.Pop(); Console.WriteLine(number + "has been popped off the stack"); } Console.ReadLine();

}

}

}

Example – Queue Collection using System; using System.Collections; namespace Collections { class sampleQueue { static void Main(string[] args) { Queue numbers = new Queue(); // fill the queue foreach (int number in new int[4] { 9, 3, 7, 2 }) { numbers.Enqueue(number); Console.WriteLine(number + " has joined the queue"); }

Example – Queue Collection.. // iterate through the queue foreach (int number in numbers) { Console.WriteLine(number); } // empty the queue while (numbers.Count != 0) { int number = (int)numbers.Dequeue(); Console.WriteLine(number + " has left the queue"); } Console.ReadLine();

}

}

}

Example - Hashtable using System; using System.Collections; namespace Collections { class sampleHash { static void Main(string[] args) { Hashtable ages = new Hashtable(); // fill the SortedList ages["John"] = 41; ages["Diana"] = 42; ages["James"] = 13; ages["Francesca"] = 11;

Example - Hashtable // iterate using a foreach statement // the iterator generates a DictionaryEntry object containing a key/value pair foreach (DictionaryEntry element in ages) { string name = (string)element.Key; int age = (int)element.Value; Console.WriteLine("Name: {0}, Age: {1}", name, age); } Console.ReadLine();

}

}

}

Example – Array List using System; using System.Collections; namespace Collections { class arrayList2 { static void Main(string[] args) { ArrayList numbers = new ArrayList(); // fill the ArrayList foreach (int number in new int[12] { 10, 9, 8, 7, 7, 6, 5, 10, 4, 3, 2, 1 }) { numbers.Add(number); } // remove first element whose value is 7 (the 4th element, index 3) numbers.Remove(7); // remove the element that's now the 7th element, index 6 (10) numbers.RemoveAt(6);

Example – Array List.. //iterate remaining 10 elements using a for statement for (int i = 0; i != numbers.Count; i++) { int number = (int)numbers[i]; // Notice the cast Console.WriteLine(number); } // iterate remaining 10 using a foreach statement foreach (int number in numbers) // No cast needed { Console.WriteLine(number); } Console.ReadLine();

}

}

}

Example – Sorted List using System; using System.Collections; namespace Collections { class sampleSortedList { static void Main(string[] args) { SortedList ages = new SortedList(); // fill the SortedList ages["John"] = 39; ages["Diana"] = 40; ages["James"] = 12; ages["Francesca"] = 10;

Example – Sorted List.. // iterate using a foreach statement // the iterator generates a DictionaryEntry object containing a key/value pair foreach (DictionaryEntry element in ages) { string name = (string)element.Key; int age = (int)element.Value; Console.WriteLine("Name: {0}, Age: {1}", name, age); } Console.ReadLine();

}

}

}

Indexers 

You can use an indexer to access members of a class as if it was an array.



Indexers are nameless and use a reserved word this for implementation.



Indexers include indexing parameters between square brackets.



To read and write values, the get and set accessors are used.



The signature of an indexer is used as a means of identification, which consists of a number and the type of the indexer’s formal parameters.

Indexers.. 

An indexer is a member that enables an object to be indexed in the same way as an array.



Example :– public string []s2 = new String[3]; – public string this[int ind] { – get {return s2[ind];} – set {s2[ind] = value;} } – obj[0] = “test” – Console.WriteLine(“{0}”, obj[0]);

Indexers.. 

Array & Indexers 

Both use array notation



Indexers can use non-integer subscripts and atleast one subscript should be provided



Indexers can be overloaded – define several indexers, each using a different index type



They are not variables, so cannot be passed to methods



Indexers cannot be static



Can be passed more than one parameter to the indexer (mainly used for 2D array)

Example – Indexers public class Index { public static void Main() { //Create a new IndexTest object a IndexTest a = new IndexTest(); //Print the value of a System.Console.WriteLine(a[1]); } }

Example – Indexers.. public class IndexTest { return 25; } } }

Delegates 

Delegates are reference types that derive from the common base class: System.Delegate.



An instance of delegate encapsulates a method, which can be called.



A delegate is independent of the object that it references.



The signature of the method should match the delegate’s signature.



Delegates are declared using the following syntax: public delegate void SimpleDelegate(); Declares a delegate named SimpleDelegate that takes no argument and returns a void.

Delegates.. 

Equivalent to function pointers



Allows a method to be called indirectly



It contains a reference to a method



All methods invoked by the same delegate must have the same parameters and return value



To use a delegate – First define it and then instantiate it

Delegates.. 

Defining – public delegate void mydelegate( ); – Defines a delegate for methods that return no value and takes no parameters



Instantiating – After defining it instantiate it and refer to a method – myclass ed1 = new myclass( ); – mydelegate callback = new mydelegate (ed1.method);



To call a Delegate callback();

Example - Delegates class DelegateTest {

static void func() {

//Static method

System.Console.WriteLine(“DelegateTest.func” ); } static void Main(){ //Static method on the class //Instantiation SimpleDelegate d = new SimpleDelegate(func); // Invocation d(); }

}

Operator Overloading 

Overloading operators that act upon objects



All are public static methods



These method names are operatorop where op specifies exactly which operator is being overloaded. Ex: operator+



All arithmetic operators return an instance of the class and manipulate objects of the same class.

Operator Overloading.. 



Relational operators 

must be paired



If you overload > then you should overload <



>= and <=, = = and !=

If you overload = = and != operators, then you should override the Equals method, such that if both returns true in a same situation



GetHashCode to be overloaded along with Equals method

Operator Overloading.. 

Same operator can be overloaded multiple times. 

public static Time operator+(Time t1, int hours)



public static Time operator+(Time t1, float hours)

Example – Operator Overloading using System; namespace _10thLesson { public class Complex { public int real = 0; public int imaginary = 0; public Complex(int real, int imaginary) { this.real = real; this.imaginary = imaginary; } public static Complex operator +(Complex c1, Complex c2) { return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary); }

Example – Operator Overloading.. public static Complex operator *(Complex c1, Complex c2) { return new Complex((c1.real * c2.real c1.imaginary * c2.imaginary), (c1.real * c2.imaginary + c1.imaginary * c2.real)); } static void { Complex Complex Complex Complex

Main(string[] ar) num1 = new Complex(5, 6); num2 = new Complex(2, 4); sum = num1 + num2; prod = num1 * num2;

Example – Operator Overloading.. Console.WriteLine("Number1 = {0} + {1}i", num1.real, num1.imaginary); Console.WriteLine("Number2 = {0} + {1}i", num2.real, num2.imaginary); Console.WriteLine("Sum = {0} + {1}i", sum.real, sum.imaginary); Console.WriteLine("Product = {0} + {1}i", prod.real, prod.imaginary);

}

}

}

Console.ReadLine();

Session Ends

Exercise

Relax