GENERIC PROGRAMMING &

COLLECTIONAdhatus Solichah A.

Course Structure

Interfaces of the System.Collections Generic methods, class, base class,

interface

System.Array

The most primitive container construct Provides services, e.g. reversing,

sorting, clearing, and enumerating Has fixed upper limit it does not automatically resize itself as

we add or clear items

System.Collections

contain types in a more flexible container

The System.Collections namespace defines a number of interfaces

Interfaces of System.Collections

System.Collections Interface

Meaning

ICollection Defines general characteristics (e.g., size, enumeration, threadsafety) for all non-generic collection types.

IComparer Allows two objects to be compared.

IDictionary Allows a non-generic collection object to represent its contentsusing name/value pairs.

IDictionaryEnumerator

Enumerates the contents of a type supporting IDictionary.

IEnumerable Returns the IEnumerator interface for a given object.

IEnumerator Enables foreach style iteration of subtypes.

IHashCodeProvider Returns the hash code for the implementing type using acustomized hash algorithm.

IList Provides behavior to add, remove, and index items in a list ofobjects. Also, this interface defines members to determinewhether the implementing collection type is read-only and/ora fixed-size container.

System.Collections Interface Hierarchy

ICollection

The most primitive interface of System.Collections ICollection extends IEnumerable Provide small set of member to determine:

a. the number of items in the container,b. the thread safety of the container,c. the ability to copy the contents into a System.Array

type.public interface ICollection : IEnumerable{int Count { get; }bool IsSynchronized { get; }object SyncRoot { get; }void CopyTo(Array array, int index);}

IDictionary

collection that maintains a set of name/value pairs

IDictionary interface defines a Keys and Values property as well as Add(), Remove(), and Contains() methods.

public interface IDictionary :ICollection, IEnumerable{bool IsFixedSize { get; }bool IsReadOnly { get; }object this[object key] { get; set; }ICollection Keys { get; }ICollection Values { get; }void Add(object key, object value);void Clear();bool Contains(object key);IDictionaryEnumerator GetEnumerator();void Remove(object key);}

IDictionaryEnumerator

IDictionaryEnumerator is simply a strongly typed enumerator, given that it extends IEnumerator

IDictionaryEnumerator allows to enumerate over items in the dictionary via the generalized Entry property

Ability to traverse the name/value pairs using the Key/Value properties. (sorting)

public interface IDictionaryEnumerator : IEnumerator{DictionaryEntry Entry { get; }object Key { get; }object Value { get; }}

IList

provides the ability to insert, remove, and index items into (or out of) a container

public interface IList :ICollection, IEnumerable{bool IsFixedSize { get; }bool IsReadOnly { get; }object this[ int index ] { get; set; }int Add(object value);void Clear();bool Contains(object value);int IndexOf(object value);void Insert(int index, object value);void Remove(object value);void RemoveAt(int index);}

Classes of System.CollectionsSystem.Col

lections Class

Meaning Key Implemented Interfaces

ArrayList Represents a dynamically sized array of objects.

IList, ICollection, IEnumerable, and ICloneable

Hashtable Represents a collection of objects identified by a numerical key. Custom types stored in a Hashtable should always override System.Object.GetHashCode().

IDictionary, ICollection, IEnumerable, and ICloneable

Queue Represents a standard first-in, first-out (FIFO) queue.

ICollection, ICloneable and IEnumerable

SortedList Like a dictionary; however, the elements can also be accessed by ordinal position (e.g., index).

IDictionary, ICollection, IEnumerable, and ICloneable

Stack A last-in, first-out (LIFO) queue providing push and pop (and peek) functionality.

ICollection, ICloneable, and IEnumerable

Working with the ArrayList Type making use of the AddRange() method

to populate ArrayList Insert() allows to plug a new item into

the ArrayList at a specified index. (zero based index)

the call to the ToArray() method returns an array of System.Object types based on the contents of the original ArrayList.

Working with the Queue Type Queues are containers that ensure items

are accessed using a first-in, first-out manner

Member of System.Collections.Que

ue

Meaning

Dequeue() Removes and returns the object at the beginning of the Queue

Enqueue() Adds an object to the end of the Queue

Peek() Returns the object at the beginning of the Queue without removing it

Working with the Stack Type represents a collection that maintains

items using a last-in, first-out manner. Stack defines a member named Push()

and Pop()

Boxing & Unboxing

Boxing Value type Ref type Implicit

Unboxing Ref type Value type Explicit

// Make a short value type.short s = 25;

// Box the value into an object reference.object objShort = s;

// Unbox the reference back into a corresponding short.short anotherShort = (short)objShort;

Boxing & Unboxing

1. A new object must be allocated on the managed heap.

2. The value of the stack-based data must be transferred into that memory location.

3. When unboxed, the value stored on the heap-based object must be transferred back to the stack.

4. The now unused object on the heap will (eventually) be garbage collected.

System.Collections.Generic Contains numerous class and interface

types that allow you to contain subitems in a variety of containers

generic interfaces mimic the corresponding nongeneric types in the System.Collections

::Non-generic::

class Bucket{public string items;

}

::Generic::

class Bucket<T>{public T item;public void Add(T value);public T GetItem();

}

Classes of System.Collections.Generic

Nongeneric Counterpart

Generic Class in System.Collections

Meaning

Collection<T> CollectionBase The basis for a generic collection

Comparer<T> Comparer Compares two generic objects for equality

Dictionary<TKey, TValue>

Hashtable A generic collection of name/value pairs

List<T> ArrayList A dynamically resizable list of items

Queue<T> Queue A generic implementation of a first-in, first-out (FIFO) list

SortedDictionary<TKey, TValue>

SortedList A generic implementation of a sorted set of name/value pairs

Stack<T> Stack A generic implementation of a last-in, first-out (LIFO) list

LinkedList<T> N/A A generic implementation of a doubly linked list

ReadOnlyCollection<T>

ReadOnlyCollectionBase

A generic implementation of a set of read-only items

Limitations of Custom Generic Collections

Generic Constraint Meaning

where T : struct The type parameter <T> must have System.ValueType in its chain of inheritance

where T : class The type parameter <T> must not have System.ValueType in its chain of inheritance (e.g., <T> must be a reference type)

where T : new() The type parameter <T>must have a default constructor. This is very helpful if your generic type must create an instance of the type parameter, as you cannot assume the format of custom constructors. Note that this constraint must be listed last on a multiconstrained type

where T : NameOfBaseClass

The type parameter <T> must be derived from the class specified by NameOfBaseClass.

where T : NameOfInterface

The type parameter <T> must implement the interface specified by NameOfInterface.Multiple interfaces can be separated as a comma-delimited list.

Possible Constraints for Generic Type Parameters

Creating Generic Base Classes generic classes can be the base class to

other classes// Assume you have created a custom// generic list class.public class MyList<T>{private List<T> listOfData = new List<T>();}// Concrete types must specify the type parameter when deriving from a// generic base class.public class MyStringList : MyList<string>{}//orpublic class MyStringList<T> : MyList<T>{}

Creating Generic Interfaces

public interface IBinaryOperations<T> where T : struct{T Add(T arg1, T arg2);T Subtract(T arg1, T arg2);T Multiply(T arg1, T arg2);T Divide(T arg1, T arg2);}

Next.......

Delegate, Events and Lambdas