Obviously from then on, everyone would implement ICollection<T> every time they make a collection, right? Not so. Here is how we used LINQ to learn about what collections really are, and how that made us change our language design in C# 3.0.

Collection initializers

With LINQ, the Language INtegrated Queryframework that we’re shipping in Orcas, we’re enabling a moreexpression-oriented style of programming. For instance it should bepossible to create and intialize an object within one expression. Forcollections, initialization typically amounts to adding an initial setof elements. Hence collection initializers in C# 3.0 look like this:

new MyNames { “<st1:personname w:st=”on”>Luke Hoban</st1:personname>”, “<st1:personname w:st=”on”>Karen Liu</st1:personname>”, “<st1:personname w:st=”on”>Charlie Calvert</st1:personname>” }

The meaning of this new syntax is simply to create an instance of MyNamesusing its no-arg constructor (constructor arguments can be supplied ifnecessary) and call its Add method with each of the strings.

So what types do we allow collection initializers on? Easy: collection types. What are those? Obvious: types that implement ICollection<T>. This is a nice and easy design – ICollection<T> ensures that you have an Addmethod so obviously that is the one that gets called for each elementin the collection initializer. It is strongly typed, too – theinitializer can contain only elements of the appropriate element type.In the above new expression, MyNames would be a class that implements ICollection<string> and everything works smoothly from there.

There’s just one problem: Nobody implements ICollection<T>!

LINQ to LINQ

Well, nobodyis a strong word. But we did an extensive study of our own frameworkclasses, and found only a few that did. How? Using LINQ of course. Thefollowing query does the trick:

from name in assemblyNames

select Assembly.LoadWithPartialName(name) into a

from c in a.GetTypes()

where c.IsPublic &&

c.GetConstructors().Any(m => m.IsPublic) &&

GetInterfaceTypes(c).Contains(typeof(ICollection<>))

select c.FullName;<o:p></o:p>

Let.s go through this query a little bit and see what it does. For each name in a list of assemblyNames that we pre-baked for the purpose, load up the corresponding assembly:

from name in assemblyNames

select Assembly.LoadWithPartialName(name)

One at a time, put the reflection objects representing these assemblies into a, and for each assembly a run through the types c defined in there:

from c in a.GetTypes()

Filter through, keeping each type only if it

a) IsPublic<o:p></o:p>

b) has Any constructor that IsPublic

c) implements ICollection<T> for some T:

where c.IsPublic &&

c.GetConstructors().Any(m => m.IsPublic) &&

GetInterfaceTypes(c).Contains(typeof(ICollection<>))

For those that pass this test, select out their full name:

select c.FullName;<o:p></o:p>

Nothing to it, really.

What is a collection?

What did we find then? Only 14 of our own (public) classes (with public constructors) implement ICollection<T>!Obviously there are a lot more collections in the framework, so it wasclear that we needed some other way of telling whether something is acollection class. LINQ to the rescue once more: With modified versionsof the query it was easy to establish that among our public classeswith public constructors there are:

<<<<<< 189 that have a public Add method and implement System.Collections.IEnumerable

<<<<<< 42 that have a public Add method but do not implement System.Collections.IEnumerable

If youlook at the classes returned by these two queries, you realize thatthere are essentially two fundamentally different meanings of the name .Add.:

a) Insert the argument into a collection, or

b) Return the arithmetic sum of the argument and the receiver.

People are actually very good at (directly or indirectly) implementing the nongeneric IEnumerable interface when writing collection classes, so that turns out to be a pretty reliable indicator of whether an Add method is the first or the second kind. Thus for our purposes the operational answer to the headline question becomes:Continues…

Collection resembles to grouping together theset of objects with the same characteristics, in programming paradigmit resembles to the set of object instances of the same class.In .NET, class libraries provides the collection interfaces that areused to develop one's own collection classes. The basic functionalityfor the collections is made available by inheriting the abstract(MustInherit in VB) Class CollectionBase from the System.Collectionnamespace. The CollectionBase class provides the implementations forthe Clear method and the Count property, and it maintains a Protectedproperty called List, which it uses for the internal storage andorganization of the object instances. Other methods such as Add andRemove as well as the Item property requires implementation to beprovided.

Steps:
Create the class for which the collection class is to be implemented:
For our discussion we will consider the following class definition.

class Leaf {
private int intAge;
private String strName;

// Default Constructor
public Leaf() {}

// gets and sets the age value
public int Age {
get {
return intAge;
}
set {
intAge = value;
}
}

// gets and sets the strName variable
public string Name {
get {
return strName;
}
set {
strName = value;
}
}
}

The class leaf has private variables intAgeand strName and exposes them through public properties Age and Name tothe outside world.
Now let us write the collection class. We will name this class as Leafs.

class Leafs: CollectionBase { }

As the above definition suggests the Leafsclass inherits from the CollectionBase abstract class. Inheriting fromthe CollectionBase class implicitly provides the List collection whichis of type IList and which represents a collection of objects that canbe individually indexed. The next step is to provide the implementationfor the methods in CollectionBase.

Implement the Add, Remove methods and Item property.

// Method implementation from the CollectionBase class
public void Add(Leaf aLeaf){
List.Add(aLeaf);
}

// Method implementation from the CollectionBase class
public void Remove(int index){
// Check to see if there is a Leaf at the supplied index.
if (index > Count – 1 || index < 0) {
// Handle the error that occurs if the valid page index is
// not supplied.
// This exception will be written to the calling function
throw new Exception("Index out of bounds");
}
List.RemoveAt(index);
}
// Method implementation from the CollectionBase class
public Leaf Item(int Index) {
// The appropriate item is retrieved from the List object and
// explicitly cast to the Leaf type, then returned to the
// caller.
return (Leaf) List[Index];
}

The above procedure will make the fullfunctional collection class for containing the collection instances ofyour own class definition. We can still improve the handling of theabove class, by adding the functionality to support the class to beused with foreach.. in.. construct. For collection class to support theenumeration functionality it can be extended to implement theIEnumerable interface.

Steps:

Extend your Collection class definition to implement IEnumerable interface:

class Leafs: CollectionBase, IEnumerable{}

Every collection is required to return theenumerator interface for the classes that provide the collectionenumeration functionality. The GetEnumerator() function formIEnumerable interface returns the Enumerator object for the collection.So we have to define the enumerator object for our collection and thenrewrite the IEnumerable.GetEnumerator() function to return theIEnumerator interface.Following is the code snippet for class Enumerator for our Leafscollection and we will name it as LeafEnumerator.

/* Define the Enumeration class to return */
public class LeafEnumerator: IEnumerator {
int nIndex;
Leafs collection;
public LeafEnumerator(Leafs coll) {
collection = coll;
nIndex = -1;
}
// Sets the enumerator to its initial position, which is
// before the first element in the collection.
public void Reset() {
nIndex = -1;
}
// Advances the enumerator to the next element of the
// collection.
public bool MoveNext() {
nIndex++;
return(nIndex < collection.Count);
}
// Gets the current element in the collection.
public Leaf Current {
get {
return((Leaf)collection.Item(nIndex));
}
}
// The current property on the IEnumerator interface:
object IEnumerator.Current {
get {
return(Current);
}
}
} // End of class LeafEnumeration

As seen above our LeafEnumerator Classimplements the IEnumerator interface. So we have to provide theimplementation for the functions Reset, MoveNext and Current. The classLeafEnumerator can exist as separate class in the same assembly or canbe inner class in our Leafs collection. It is best practice to have itas the inners class because it will hardly be used directly inapplication.
Now we will provide the base implementation for theIEnumerable.GetEnumerator() and a new implementation for the functionGetEnumerator() in the following manner

// Implement the method GetEnumerator from the interface
//IEnumerable
public new LeafEnumerator GetEnumerator() {
return new LeafEnumerator(this);
}
// Implement the GetEnumerator() method:
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}

And we are done. Now let us test our Collection class. In the following code we
? Create the instance of the collection class.
? Adds the Leafs items to the collection
? Iterates through the collection Items and displays the output on to the console.

class Entry{
public static void Main() {
Leafs lfc = new Leafs();
Leaf lf = new Leaf();
lf.Age = 10;
lf.Name = "Paresh";
Leaf lf1 = new Leaf();
lf1.Age = 100;
lf1.Name = "Sharmili";
lfc.Add(lf);
lfc.Add(lf1);
foreach(Leaf l in lfc) {
Console.WriteLine("Name : " + l.Name + " Age : " + l.Age);
}
}
}

Output displayed at the console:Name : Paresh Age : 10Name : Sharmili Age : 100

It is always a good practice to usecollections over arrays when dealing with the reference data types. Itavoids most of the runtime error that can occur when using the arrays.Also it relives the programmer from tracking for the array index beinginvalid. At the same time it makes the code look cleaner and morereadable.

To construct and manipulate a collection of objects, .Net framework has provided us with many classes. ArrayList, BitArray, HashTable, SortedList, Queue and Stack are some of them. They are all included in System.Collections namespace.

Download myQueue.cs

Download myStack.cs

In general, Arrays are not dynamic in nature and do not allow the user to remove an element easily. An ArrayList is like an expandable array of objects. Its Add, Insert, Remove RemoveAt methods make it relatively easy to insert and remove elements from the ArrayList. But we cannot refer to an entry in an ArrayList by a key. HastTable solves this problem but it does not allow its entries to be addressed using indexes. It also does not allow us to retrieve the entries in any particular order. SortedList represents a collection of associated keys & values. The values are sorted by key and are accessible by key and by Index.

The purpose of this paper is to demonstrate the use of stack and Queue classes, identify their key strengths and limitations. This paper first explains the stack/queue concept and then applies the concept to an example. The program is explained with the help of comment lines.

STACK

Stack class is generally referred to as LIFO (Last In First Out). The best example could be “a stack of plates in the fabrication company”. The last plate placed on the stack is the first one to be removed. Stack in implemented as circular buffer. The various methods of stack class are

Push
Inserts an object at the top of the Stack

Pop
Returns and permanently removes the object at the top of the Stack

Peek
Returns the object at the top of the Stack without removing it

Clear
Clears the stack by removing all objects from the Stack

Clone
Creates a shallow copy of the Stack

CopyTo
Copies the Stack to an existing one-dimensional Array

ToArray
Copies the Stack to a new array

Contains
Determines if an element is present in the Stack

Equals
Determines if two Object instances are equal

ToString
Returns a String that represents the current Object

GetEnumerator, GetHashCode and GetType are also some of the methods of stack class.
Count, IsReadOnly, IsSynchronized, SyncRoot are the properties of Stack class.

The initial capacity is the starting capacity of the new stack. Once current capacity is reached, the capacity is doubled. The default initial capacity is 10. Almost all the methods of Stack class, except Synchronized method are virtual and can be overridden by the derived class. Stack is not thread-safe, To guarantee thread safety of a stack, all operations must be done through the wrapper returned by the Synchronized method.

Example using Queue

The Code

// This example uses all the important methods of a stack class
using System;
using System.Collections;
public class myStack
{
public static void Main()
{ // Create and instantiate new Stack
Stack myStack = new Stack();
// Adding 4 objects to the stack
myStack.Push(“Vijay”);
myStack.Push(“Vikas”);
myStack.Push(“Emill”);
myStack.Push(“Rajiv”);
// Create and initialize one-dimensional Array
Array myArray=Array.CreateInstance(typeof(String),15);
// Add 5 elements to the array
myArray.SetValue(“student1″, 0);
myArray.SetValue(“student2″, 1);
myArray.SetValue(“student3″, 2);
myArray.SetValue(“student4″, 3);
myArray.SetValue(“student5″, 4);
// Count the number of objects in the stack
Console.Write(“Total number of objects in the stack : ” );
Console.Write(myStack.Count);
// Print all the objects in the stack
Console.Write(“\nThe objects are :”);
PrintValues(myStack);
Console.WriteLine();
Console.WriteLine(“\tObject no \t3\t2\t1\t0″);
// Remove an element from the stack (Last In First Out)
Console.WriteLine();
Console.WriteLine(“Pop removes&shows Last element of the stack first”);
Console.Write(“The element removed is : ” );
Console.Write(“\t{0}”, myStack.Pop());
// Show an element from the stack
Console.WriteLine(“\nPeek method just shows an element but does not
remove it from the stack”);
Console.Write(“The element shown is : ” );
Console.Write(“\t{0}”, myStack.Peek());
Console.WriteLine();
// Count and print the number of objects in the stack
Console.Write(“\nTotal remaining number of objects in the stack : ” );
Console.Write(myStack.Count);
Console.WriteLine();
Console.Write(“\nThe objects are :”);
PrintValues(myStack);
Console.WriteLine();
Console.WriteLine(“\tObject no \t2\t1\t0″);;
// Clear the Stack.
myStack.Clear();
Console.WriteLine();
Console.Write(“The stack is cleared. Now, total number of objects = “);
Console.Write(myStack.Count);
Console.WriteLine();
// Refill the stack with different values
myStack.Push(“Patil”);
myStack.Push(“Agarwal”);
myStack.Push(“Tsankov”);
myStack.Push(“Gomes”);
myStack.Push(“Smith”);
// Count and print the number of objects in the stack
Console.WriteLine();
Console.Write(“Total number of NEW objects in the stack : ” );
Console.Write(myStack.Count);
Console.WriteLine();
Console.Write(“\nThe objects are :”);
PrintValues(myStack);
Console.WriteLine();
Console.WriteLine(“\tObject no \t4\t3\t2\t1\t0″);
Console.WriteLine();
// Display the values of the target Array instance.
Console.WriteLine(“The target Array contains following elements BEFORE
copying):” );
PrintValues(myArray,’ ‘);
// Copy the entire source Stack to target Array, starting at index 3.
myStack.CopyTo( myArray, 3 );
Console.WriteLine();
Console.WriteLine(“The target Array contains following elements AFTER
copying):” );
PrintValues(myArray,’ ‘);
}
Continues…

This sample shows a simple custom collection implementation in C# with the .NET Framework.

using System;
using System.Collections;

namespace Personal.Demos.Simple{

public class MainApp{

//entry point 'Main'

public static void Main(){

//get us some Widgets
Widgets MyWidgets = Initialize();

Console.WriteLine("Using 'foreach' – ");

//enumerate through the collection with
//the foreach constuct.

foreach(Widget W in MyWidgets){
//call the same method on each item in
//the collection.
Console.WriteLine(W.AMethod());
}

Console.WriteLine("Using 'Indexers' – ");

//enumerate through the collection with
//it's indexer.

for(int i=0; i < MyWidgets.Count ; i++){
//call the same method on each item in
//the collection.
Console.WriteLine(MyWidgets[i].AMethod());
}

}

//fill up a 'Widgets' collection with…
//…well some Widgets.

private static Widgets Initialize(){

Widgets colWidgets = new Widgets();
Widget objWidget;
int i;

for(i=0 ; i < 10 ; i++){
objWidget = new Widget();
objWidget.Number=i;
colWidgets.Add(objWidget);
}

return colWidgets;
}

}

//*****************************************************
//the individual Widget class

public class Widget{

public int Number=0;

public virtual string AMethod(){

return "This Widget's Number is : "
+ Number.ToString();

}
}

//*****************************************************
//Widgets collection class MUST derive from
//System.Collections.CollectionBase

public class Widgets:CollectionBase{

public virtual void Add(Widget NewWidget){
//forward our Add method on to
//CollectionBase.IList.Add
this.List.Add(NewWidget);

}

//this is the indexer (readonly)
public virtual Widget this[int Index]{

get{
//return the Widget at IList[Index]
return (Widget)this.List[Index];

}

}
}
//*****************************************************
}