The System.Collections namespace contains interfaces and classes that define various collections of objects, such as lists, queues, bit arrays, hash tables and dictionaries.

 Classes

 Structures

 Interfaces

The System.Collections.Generic namespace contains interfaces and classes that define generic collections, which allow users to create strongly typed collections that provide better type safety and performance than non-generic strongly typed collections.

 Classes

 Structures

 Interfaces

If you look at the .NET framework documentation, you will be overwhelmed with the amount of types that are there. There are over 7000+ types in the framework class library and they cater to all the needs of computing ever envisaged. There are data structures for representing collections, hash tables, dictionaries, network protocols and so onThe System.Collections namespace contains a series of types for representing various types of collections, which can be used to store objects of various types and retrieved according to the access method dictated by the collection.

In this article, I’m going to look at the Stack type that is present in the System.Collections namespace and see how the stack can be used for programming tasks. I will show some simple examples that show the operation of this collection and then use these concepts to build upon an application that will perform more meaningful tasks. But before we start on the examples, some basics�

What is a stack?

If you look at any book on data structures, a stack is defined as a last in first out list. We will stick to this definition and not complicate it further!

By last-in-first-out what we mean is, if a set of objects are put into a stack, the last object that was put in, will be the first object to be taken out. For example, if you see in restaurants that have an automatic plate dispenser, a stack of plates are kept and as each person takes a plate, the next plate in the stack becomes available. Diagrammatically, this looks like the following:

The operation of putting an object into a stack is called push and the operation of taking an object out of the stack is called pop. Sometimes, it might be required to just “examine” the top element from a stack without taking it out. This operation is called peek. This simple data structure represents a very common concept that we keep seeing/doing in our daily lives!!

There are many ways to program a stack. The traditional method has been to represent a stack by means of an array (wrapped around a class) and then provide methods that allow the operations discussed above. If you are a Visual Basic programmer, you can see an implementation at: http://www.developersdomain.com/vb/articles/stack.htm.

Rather than having various implementations of stacks floating around by programmers, the .NET team has provided a type called Stack that provides the above discussed features and operations and more.

Stack in .NET

In .NET, the stack type is present in the System.Collections namespace. The following are the operations available to us on a Stack object.

Public Constructors

• Stack constructor. This is an overloaded constructor that initializes a Stack.

Public Properties

• Count. This property gets the number of elements in the stack.
• IsSynchronized. Gets a value indicating whether access to the Stack is synchronized (thread-safe).
• SyncRoot. Gets an object that can be used to synchronize access to the Stack.

Public Methods

• Clear. Removes all objects from the Stack.
• Clone. Creates a shallow copy of the Stack.
• Contains. Determines whether an element is in the Stack.
• CopyTo. Copies the Stack to an existing one-dimensional Array, starting at the specified array index.
• GetEnumerator. Returns an IEnumerator for the Stack.
• Peek. Returns the object at the top of the Stack without removing it.
• Pop. Removes and returns the object at the top of the Stack.
• Push. Inserts an object at the top of the Stack.
• Synchronized.Returns a synchronized (thread-safe) wrapper for the Stack.
• ToArray. Copies the Stack to a new array.

All collections also inherit from System.Object. Therefore all the methods from the base class are also available for access.

We will not see examples of all the above methods, but only see the important ones. For more information on each of these methods, see the .NET Framework documentation.

A simple stack example

Ok, enough of the basics. Let’s get down to work. Fire up Visual Studio .NET and choose Console Application (Visual Basic .NET) as the project type and type in the following code into the editor.

Collapse Copy Code

Imports System.Collections

Module TestModule

    Sub Main()

        ‘ Declare and initialize a stack type

        Dim oStack As Stack

        oStack = New Stack

        ‘ Push some elements into the stack. Note that this

        ‘ can be any object

        oStack.Push(“1″)

        oStack.Push(“2″)

        ‘ Print some statistics about the stack

        Console.WriteLine(“Stack Count = {0}”, oStack.Count())

        Console.WriteLine(“Top Element = {0}”, oStack.Peek())

        Console.WriteLine(“Get First Element = {0}”, oStack.Pop())

        ‘ Clear the contents of the stack

        oStack.Clear()

        ‘ Print some statistics about the stack

        Console.WriteLine(“Stack Count = {0}”, _

                                 oStack.Count())

        ‘ Wait for some console input so

        ‘ that we can see the output from

        ‘ the above lines

        Console.Read()

    End Sub

End Module

Note that I’ve changed the module name to TestModule. This means that you have to change the VS.NET project properties to set the startup object as TestModule.

And that’s it!! We have a stack implemented. The output of the program will be as follows:

So what did we do? We created a stack and then pushed two items into it using the push method. Then, using some of the Stack object methods, we print some details about the stack. Note that the peek method did not remove the top element. Finally, we clear the stack and print the count and its 0, indicating that the stack is now empty.

That was a very simple example that showed some details about the stack. Now, let’s build a more interesting application.

The Reverse Polish Notation calculator

In this section, we are going to build a simple calculator application that well, adds and subtracts numbers (there are more sophisticated calculators in the market, but we are going to keep it simple!!).

The method that we are going to use to represent the calculator object is by using a notation called the reverse polish notation. You can find more details about this at: http://www.calculator.org/rpn.html. Essentially, in the polish calculator, the various operators and operands are “pushed” and “popped” from a stack to obtain the results. To start with, as and when we encounter numbers, we “push” them onto the stack and when we start encountering operators, we “pop” the values from the stack, do the operation and “push” the result onto the stack. So let’s take a simple example: Say we want to evaluate the expression (3 + 5) * (7 � 2). In the RPN calculator, this expression would be represented as 3 5 + 7 2 – * and from a programming perspective would be made of the following steps:

• Push 3 onto the stack.
• Push 5 onto the stack. The stack now contains (3, 5).
• Apply the + operation: take the top two numbers off the stack, add them together, and put the result back on the stack. The stack now contains just the number 8.
• Push 7 onto the stack.
• Push 2 onto the stack. It now contains (8, 7, 2).
• Apply the – operation: take the top two numbers off the stack, subtract the top one from the one below, and put the result back on the stack. The stack now contains (8, 5).
• Apply the * operation: take the top two numbers off the stack, multiply them together, and put the result back on the stack. The stack now contains just the number 40.

This looks pretty interesting, right? So let’s model a .NET class for doing this operation for us. In the VS.NET project opened earlier, right click and add a new class module (called PolishCalc). Paste the code from the following snippet onto the editor.

Collapse Copy Code

‘ This class is used to evaluate a

‘ reverse polish notation calculator

Imports System.Collections

Public Class PolishCalc

    Private oStack As Stack

    ‘ A constructor that takes no argument

    Public Sub New()

        ‘ Initialize the internal stack for use

        oStack = New Stack

    End Sub

    ‘ Fetch the result from the stack.

    ‘ Note that the top element from the

    ‘ stack is returned without removing it

    Public ReadOnly Property Result()

        Get

            Return (oStack.Peek())

        End Get

    End Property

    ‘ This function will evaluate an expression

    ‘ that is expressed in the

    ‘ reverse polish notation. For example: 35+27-*

    Public Function Evaluate(ByVal Expression_

                          As String) As Integer

        Dim nLength As Integer, i As Integer,_

                            nValue As Integer

        Dim strValue As String

        nLength = Expression.Length()

        For i = 0 To (nLength – 1)

            ‘ Get the character at the required position

            strValue = (Expression.Chars(i)).ToString()

            ‘ Evaluate the expression that was fetched

            Select Case strValue

                Case “+”

                    ‘ Retrieve two values from

                    ‘ the stack, calculate the sum

                    ‘ and push the result back

                    nValue = CType(oStack.Pop(), Integer) _

                            + CType(oStack.Pop(), Integer)

                    oStack.Push(nValue.ToString())

                Case “-”

                    ‘ Retrieve two values from the stack,

                    ‘ calculate the difference

                    ‘ and push the result back

                    nValue = CType(oStack.Pop(), _

                      Integer) – CType(oStack.Pop(), Integer)

                    oStack.Push(nValue.ToString())

                Case “*”

                    ‘ Retrieve two values from the stack,

                    ‘ calculate the product

                    ‘ and push the result back

                    nValue = CType(oStack.Pop(), _

                        Integer) * CType(oStack.Pop(), Integer)

                    oStack.Push(nValue.ToString())

                Case Else

                    ‘ It will be a number, so push it onto the stack

                    oStack.Push(strValue)

            End Select

        Next

    End Function

    ‘ Clear the polish calculator

    Public Function Clear()

        oStack.Clear()

    End Function

End Class

The above code represents a simple calculator with 3 operations (+, – and *). As mentioned in the polish specification, we use a stack to model all out operations. The result of the expression is available as a read-only property called Result. Note that we use the peek function to return the result, since we want the last result to be available in the stack for any other operations. Finally, we have a clear method that allows us to start all over again.

Ok, let’s test our code. Go back to the console application in the VS.NET solution window and type in the following code:

Collapse Copy Code

Imports System.Collections

Module TestModule

    Sub Main()

        ‘ Initialize our polish calculator

        Dim oPolish As PolishCalc

        oPolish = New PolishCalc

        ‘ Evaluate a simple expression and print the results

        oPolish.Evaluate(“35+27-*”)

        Console.WriteLine(“Result = {0}”, oPolish.Result)

        ‘ Work on the previous result

        oPolish.Evaluate(“5+”)

        Console.WriteLine(“Result = {0}”, oPolish.Result)

        ‘ Clear our calculator

        oPolish.Clear()

        ‘ Wait for some input so that we

        ‘ can see the results in the

        ‘ output window

        Console.Read()

    End Sub

End Module

The output from the previous program would be 40 and 45. Since the Result property does not remove the latest value from the stack, we are able to add another expression to it.

Advanced concepts

The above representation of the Stack worked well because you were the only one accessing it. If you deployed this application and had multiple threads working on this stack, then how do you guarantee that other threads do not read off the stack or manipulate it when you are working on it? The answer is to use synchronization. The Stack class provides properties and methods that will help you to synchronize access to the stack while accessing it. A sample access method would be:

Collapse Copy Code

SyncLock oStack.SyncRoot

   ‘ Do the operations here

End SyncLock

The above code lets you perform thread safe operations on the stack so that you do not encounter sudden exceptions. For more information, see the .NET framework documentation.

What’s next?

Well, if you are adventurous and want to learn .NET more, you could try a lot of things in this program. Here are some of my thoughts�

• Implement error handling in the pop and push operations.
• Handle numbers greater than 10. Our calculator does not handle this, since we split the string character-by-character.
• Handle other operations like dividing, modulus etc.
• Handling floating point numbers.
• And many more�. All the best!!

Conclusion

The System.Collections is a vast namespace and we have seen the application of just of one its types called Stack. In the future articles, I will touch upon the other collection types that are more interesting.

License

public class Test<T> 
{
    public void Display() 
      {
          //Some code
      }
//Other members
}

Test<int> test = new Test<int>();

using System;  
using System.Collections.Generic;  
 
   class Test  
   {  
      static void Main( string[] args )  
      {  
        Test t = new Test();
        int[] integerArray = {1,2,3,4,5,6};  
        char[] characterArray = { 'J', 'O', 'Y', 'D', 'I','P' };   
        double[] doubleArray = {0.1,0.2,0.3,0.4,0.5,0.6};  
         Console.WriteLine( "Displaying the contents of the integer array:--" );  
         t.Display(integerArray);
         Console.WriteLine( "Displaying the contents of the character array:--" );
         t.Display(characterArray);
         Console.WriteLine( "Displaying the contents of the double array:--" );
         t.Display(doubleArray);
      }   
     
      public void Display< GenericArray >( GenericArray[] array )  
      {  
         for (int i = 0; i< array.Length; i++)  
            Console.WriteLine(array[i]);  
      }
   }

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Generics
{
    public class CustomStack
    {
        const int size = 10;
        private object[] register;
 
        private int count = 0;
 
        private CustomStack()
        {
            register = new object[size];
        }
        public void Push(object x)
        {
            if (count < size)
                register[count++] = x;
        }
        public object Pop()
        {
            return register[--count];
        }
        static void Main(string[] args)
        {
            CustomStack intStack = new CustomStack();
            intStack.Push(10);
            int i = (int)intStack.Pop();
            Console.WriteLine(i);
            Console.Read();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Generics
{
    public class CustomStack<S>
    {
        const int size = 10;
        private S[] register;
        private int count = 0;
 
        public CustomStack()
        {
            register = new S[size];
        }
 
        public void Push(S x)
        {
            if (count < size)
                register[count++] = x;
        }
 
        public S Pop()
        {
            return register[--count];
        }     
   }
 
    public class Test
    {
        static void Main(string[] args)
        {
            CustomStack<int> intStack = new CustomStack<int>();
            intStack.Push(10);
            int i = intStack.Pop();
            Console.WriteLine(i);
            Console.Read();
        }
    }
}

Generics are the most useful C# 2.0 language extensions, beside Anonymous methods, Iterators, Partial types And Nullable types.

Generics were added to version 2.0 of the C# language and the common language runtime (CLR). Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code. For example, by using a generic type parameter T you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations, as shown here:

What are generics?

Generics permit classes, structs, interfaces, delegates, and methods to be parameterized by the types of data they store and manipulate.

Why generics?

To well know the useful of generics lets examine the following code:

public class Stack
{
object[] items;
int count;
public void Push(object item) {…}
public object Pop() {…}
}

We use the object type to store any type of data. The above simple Stack class stores its data in an object array, and its two methods, Push and Pop, use object to accept and return data. While the use of type object makes the Stack class very flexible, it is not without drawbacks. For example, it is possible to push a value of any type, such a Customer instance, onto a stack.

However, when a value is retrieved, the result of the Pop method must explicitly be cast back to the appropriate type, which is tedious to write and carries a performance penalty for run-time type checking: 

Stack stack = new Stack();
stack.Push(new Customer());
Customer c = (Customer)stack.Pop();

If a value of a value type, such as an int, is passed to the Push method, it is automatically boxed. When the int is later retrieved, it must be unboxed with an explicit type cast:

Stack stack = new Stack();
stack.Push(3);
int i = (int)stack.Pop();

Such boxing and unboxing operations add performance overhead since they involve dynamic memory allocations and run-time type checks.

A further issue with the Stack class is that it is not possible to enforce the kind of data placed on a stack. Indeed, a Customer instance can be pushed on a stack and then accidentally cast it to the wrong type after it is retrieved:

Stack stack = new Stack();
stack.Push(new Customer());
string s = (string)stack.Pop();

While the code above is an improper use of the Stack class, the code is technically speaking correct and a compile-time error is not reported. The problem does not become apparent until the code is executed, at which point an InvalidCastException is thrown.

With generics those problems are all solved. HOW…?

public class Stack<T>
{
T[] items;
int count;
public void Push(T item) {…}
public T Pop() {…}
}

When the generic class Stack<T> is used, the actual type to substitute for T is specified. In the following example, int is given as the type argument for T:

Stack<int> stack = new Stack<int>();
stack.Push(3);
int x = stack.Pop(); 

The Stack<int> type is called a constructed type. In the Stack<int> type, every occurrence of T is replaced with the type argument int. When an instance of Stack<int> is created, the native storage of the items array is an int[] rather than object[], providing substantial storage efficiency compared to the non-generic Stack. Likewise, the Push and Pop methods of a Stack<int> operate on int values, making it a compile-time error to push values of other types onto the stack, and eliminating the need to explicitly cast values back to their original type when they’re retrieved.

Generics provide strong typing, meaning for example that it is an error to push an int onto a stack of Customer objects. Just as a Stack<int> is restricted to operate only on int values, so is Stack<Customer> restricted to Customer objects, and the compiler will report errors on the last two lines of the following example:

Stack<Customer> stack = new Stack<Customer>();
stack.Push(new Customer());
Customer c = stack.Pop();
stack.Push(3); // Type mismatch error
int x = stack.Pop(); // Type mismatch error

It was a breif introduction to generics that will be included in the next version of C# (V 2.0) . which is available now on its beta version with Visual C# 2005 Express Edition Beta 1.

Iam beginner using LIST. After study the many example, so far i’ve have below class

public class ShoppingCartItem

{

//TrxNo

private int _trxNo = 0;

public int TrxNo

{

get { return _trxNo; }

set { _trxNo = value; }

}

//Order Date

private string _OrdDate = “”;

public string OrdDate

{

get { return _OrdDate; }

private set { _OrdDate = value; }

}

//Product ID

private string _id = “”;

public string ID

{

get { return _id; }

private set { _id = value; }

}

//Product Description

private string _Desc = “”;

public string Desc

{

get { return _Desc; }

private set { _Desc = value; }

}

//Quantity

private int _quantity = 1;

public int Quantity

{

get { return _quantity; }

set { _quantity = value; }

}

//Price Per Unit

private decimal _unitPrice;

public decimal UnitPrice

{

get { return _unitPrice; }

private set { _unitPrice = value; }

}

private decimal _subTotal;

public decimal SubTotal {

get { return _subTotal; }

private set { _subTotal = value; }

}

public ShoppingCartItem(int trxno,string ordDate, string id, string desc, int quantity, decimal unitPrice, decimal subTotal)

{

this.TrxNo = trxno;//UniqueID

this.OrdDate = ordDate;//Order Date

this.ID = id;//Product ID

this.Desc = desc;//Product Description

this.Quantity = quantity;//Order Quantity

this.UnitPrice = unitPrice;//Price Per Quantity

this.SubTotal = subTotal;//Price Per Quantity

}

}

For insert into the LIST, i’ve using

order.Add(new ShoppingCartItem(Convert.ToInt32(Request.QueryString["trxNo"]), Request.QueryString["ordDate"],

Request.QueryString["id"], Request.QueryString["desc"], Convert.ToInt32(Request.QueryString["quantity"]),

Convert.ToDecimal(Request.QueryString["priceperquantity"], ,

Convert.ToDecimal(Request.QueryString["subTotal"])));

Session["Order"] = order; // this all value will display using GridView.

Let’s say i’ve current LIST as follow,

TrxNo  | OrdDate  | ID    | Quantity     | PricePerQuantity       | SubTotal

These interfaces are discussed in the same article for two reasons. These interfaces are frequently used together, and although the interfaces are similar (and have similar names), they serve different purposes.

If you have an array of types (such as string or integer) that already support IComparer, you can sort that array without providing any explicit reference to IComparer. In that case, the elements of the array are cast to the default implementation of IComparer (Comparer.Default) for you. However, if you want to provide sorting or comparison capability for your custom objects, you must implement either or both of these interfaces.

The following .NET Framework Class Library namespace is referenced in this article:

System.Collections

Back to the top

IComparable

The role of IComparable is to provide a method of comparing two objects of a particular type. This is necessary if you want to provide any ordering capability for your object. Think of IComparable as providing a default sort order for your objects. For example, if you have an array of objects of your type, and you call the Sort method on that array, IComparable provides the comparison of objects during the sort. When you implement the IComparable interface, you must implement the CompareTo method, as follows:

// Implement IComparable CompareTo method - provide default sort order.

int IComparable.CompareTo(object obj)

{

   car c=(car)obj;

   return String.Compare(this.make,c.make);

}

The comparison in the method is different depending on the data type of the value that is being compared. String.Compare is used in this example because the property that is chosen for the comparison is a string.

Back to the top

IComparer

The role of IComparer is to provide additional comparison mechanisms. For example, you may want to provide ordering of your class on several fields or properties, ascending and descending order on the same field, or both.

Using IComparer is a two-step process. First, declare a class that implements IComparer, and then implement the Compare method:

private class sortYearAscendingHelper : IComparer

{

   int IComparer.Compare(object a, object b)

   {

      car c1=(car)a;

      car c2=(car)b;

      if (c1.year > c2.year)

         return 1;

      if (c1.year < c2.year)

         return -1;

      else

         return 0;

   }

}

Note that the IComparer.Compare method requires a tertiary comparison. 1, 0, or -1 is returned depending on whether one value is greater than, equal to, or less than the other. The sort order (ascending or descending) can be changed by switching the logical operators in this method.

The second step is to declare a method that returns an instance of your IComparer object:

public static IComparer sortYearAscending()

{      

   return (IComparer) new sortYearAscendingHelper();

}

In this example, the object is used as the second argument when you call the overloaded Array.Sort method that accepts IComparer. The use of IComparer is not limited to arrays. It is accepted as an argument in a number of different collection and control classes.

Back to the top

Step-by-Step Example

The following example demonstrates the use of these interfaces. To demonstrate IComparer and IComparable, a class named car is created. The car object has the make and year properties. An ascending sort for the make field is enabled through the IComparable interface, and a descending sort on the make field is enabled through the IComparer interface. Both ascending and descending sorts are provided for the year property through the use of IComparer.

1.    In Visual C#, create a new Console Application project. Name the application ConsoleEnum.

2.    Rename Program.cs as Host.cs, and then replace the code with the following code.

Note In Visual Studio .NET 2003, rename Class1.cs as Host.cs.

3.    using System;

4.     

5.    namespace ConsoleEnum

6.    {

7.       class host

8.       {

9.          [STAThread]

10.        static void Main(string[] args)

11.        {

12.           // Create an arary of car objects.      

13.           car[] arrayOfCars= new car[6]

14.           {

15.              new car("Ford",1992),

16.              new car("Fiat",1988),

17.              new car("Buick",1932),

18.              new car("Ford",1932),

19.              new car("Dodge",1999),

20.              new car("Honda",1977)

21.           };

22.        

23.           // Write out a header for the output.

24.           Console.WriteLine("Array - Unsorted\n");

25.   

26.           foreach(car c in arrayOfCars)

27.              Console.WriteLine(c.Make + "\t\t" + c.Year);

28.        

29.           // Demo IComparable by sorting array with "default" sort order.

30.           Array.Sort(arrayOfCars);

31.           Console.WriteLine("\nArray - Sorted by Make (Ascending - IComparable)\n");

32.   

33.           foreach(car c in arrayOfCars)

34.              Console.WriteLine(c.Make + "\t\t" + c.Year);

35.   

36.           // Demo ascending sort of numeric value with IComparer.

37.           Array.Sort(arrayOfCars,car.sortYearAscending());

38.           Console.WriteLine("\nArray - Sorted by Year (Ascending - IComparer)\n");

39.   

40.           foreach(car c in arrayOfCars)

41.              Console.WriteLine(c.Make + "\t\t" + c.Year);

42.   

43.           // Demo descending sort of string value with IComparer.

44.           Array.Sort(arrayOfCars,car.sortMakeDescending());

45.           Console.WriteLine("\nArray - Sorted by Make (Descending - IComparer)\n");

46.   

47.           foreach(car c in arrayOfCars)

48.              Console.WriteLine(c.Make + "\t\t" + c.Year);

49.   

50.           // Demo descending sort of numeric value using IComparer.

51.           Array.Sort(arrayOfCars,car.sortYearDescending());

52.           Console.WriteLine("\nArray - Sorted by Year (Descending - IComparer)\n");

53.   

54.           foreach(car c in arrayOfCars)

55.              Console.WriteLine(c.Make + "\t\t" + c.Year);

56.       

57.           Console.ReadLine();

58.        }

59.     }

60.  }

61.  Add a class to the project. Name the class car.

62.  Replace the code in Car.cs with the following:

63.  using System;

64.  using System.Collections;

65.  namespace ConsoleEnum

66.  {   

67.     public class car : IComparable

68.     {      

69.        // Beginning of nested classes.

70.   

71.        // Nested class to do ascending sort on year property.

72.        private class sortYearAscendingHelper: IComparer

73.        {

74.           int IComparer.Compare(object a, object b)

75.           {

76.              car c1=(car)a;

77.              car c2=(car)b;

78.   

79.              if (c1.year > c2.year)

80.                 return 1;

81.   

82.              if (c1.year < c2.year)

83.                 return -1;

84.   

85.              else

86.                 return 0;

87.           }

88.        }

89.   

90.        // Nested class to do descending sort on year property.

91.        private class sortYearDescendingHelper: IComparer

92.        {

93.           int IComparer.Compare(object a, object b)

94.           {

95.              car c1=(car)a;

96.              car c2=(car)b;

97.   

98.              if (c1.year < c2.year)

99.                 return 1;

100.    

101.               if (c1.year > c2.year)

102.                  return -1;

103.    

104.               else

105.                  return 0;

106.            }

107.         }

108.    

109.         // Nested class to do descending sort on make property.

110.         private class sortMakeDescendingHelper: IComparer

111.         {

112.            int IComparer.Compare(object a, object b)

113.            {

114.               car c1=(car)a;

115.               car c2=(car)b;

116.                return String.Compare(c2.make,c1.make);

117.            }

118.         }

119.    

120.         // End of nested classes.

121.    

122.         private int year;

123.         private string make;

124.           

125.         public car(string Make,int Year)

126.         {

127.            make=Make;

128.            year=Year;

129.         }

130.    

131.         public int Year

132.         {

133.            get  {return year;}

134.            set {year=value;}

135.         }

136.    

137.         public string Make

138.         {

139.            get {return make;}

140.            set {make=value;}

141.         }

142.    

143.         // Implement IComparable CompareTo to provide default sort order.

144.         int IComparable.CompareTo(object obj)

145.         {

146.            car c=(car)obj;

147.            return String.Compare(this.make,c.make);

148.         }

149.    

150.         // Method to return IComparer object for sort helper.

151.         public static IComparer sortYearAscending()

152.         {      

153.            return (IComparer) new sortYearAscendingHelper();

154.         }

155.    

156.         // Method to return IComparer object for sort helper.

157.         public static IComparer sortYearDescending()

158.         {      

159.            return (IComparer) new sortYearDescendingHelper();

160.         }

161.    

162.         // Method to return IComparer object for sort helper.

163.         public static IComparer sortMakeDescending()

164.         {      

165.           return (IComparer) new sortMakeDescendingHelper();

166.         }

167.    

168.      }

169.   }

170.               Run the project. The following output appears in the Console window:

171.   Array - Unsorted

172.    

173.   Ford            1992

174.   Fiat            1988

175.   Buick           1932

176.   Ford            1932

177.   Dodge           1999

178.   Honda           1977

179.    

180.   Array - Sorted by Make (Ascending - IComparable)

181.    

182.   Buick           1932

183.   Dodge           1999

184.   Fiat            1988

185.   Ford            1932

186.   Ford            1992

187.   Honda           1977

188.    

189.   Array - Sorted by Year (Ascending - IComparer)

190.    

191.   Ford            1932

192.   Buick           1932

193.   Honda           1977

194.   Fiat            1988

195.   Ford            1992

196.   Dodge           1999

197.    

198.   Array - Sorted by Make (Descending - IComparer)

199.    

200.   Honda           1977

201.   Ford            1932

202.   Ford            1992

203.   Fiat            1988

204.   Dodge           1999

205.   Buick           1932

206.    

207.   Array - Sorted by Year (Descending - IComparer)

208.    

209.   Dodge           1999

210.   Ford            1992

211.   Fiat            1988

212.   Honda           1977

213.   Buick           1932

214.   Ford            1932

Adding a attribute to a button and when buttonclick event occur it call javascript “OPENADDWINDOW” to open New window.

function openAddWindow()
{
var client  = window.document.getElementById(“ctl00_cntTwo_ddlClients”);
var clientid = client.options[client.selectedIndex].value;

var Circle = window.document.getElementById(“ctl00_cntTwo_ddlCircles”);
var circleid = Circle.options[Circle.selectedIndex].value;

var Hub = window.document.getElementById(“ctl00_cntTwo_ddlHubs”);
var Hubid = Hub.options[Hub.selectedIndex].value;

var Query =’clientid=’+ clientid;
Query = Query +’&projid=’+circleid;
Query = Query +’&hubid=’+Hubid;

var link=’../Sites/SiteDetailsMain.aspx?status=Add&’+Query;
window.open(link,”SiteAdd”);//’height=550,width=780,status=yes,addressbar=yes’
return false;

<asp:DataList ID=”DataList1″ runat=”server” RepeatColumns=”5″ RepeatDirection=”Horizontal”
Height=”165px” Width=”587px” OnItemDataBound=”DataList1_ItemDataBound” >
<ItemTemplate>
<table>
<tr>
<td >
<asp:Image ID=”img” runat=”server” Width=100 Height=100  /><br />
<asp:LinkButton runat =”server” ID =”lnk” Text = “dfgdfgdfgd” Width =”10px”></asp:LinkButton>
</td>
</tr>
</table>
</ItemTemplate>
</asp:DataList

online.cs

protected void Page_Load(object sender, EventArgs e)
{
con.Open();
SqlDataAdapter da = new SqlDataAdapter(“select * from img”, con);
DataSet ds = new DataSet();
da.Fill(ds);
DataList1.DataSource = ds.Tables[0];
DataList1.DataBind();

}

protected void DataList1_ItemDataBound(object sender, DataListItemEventArgs e)
{
DataRowView drv = (DataRowView)e.Item.DataItem;
((Image)(e.Item.FindControl(“img”))).ImageUrl = drv.Row.ItemArray[1].ToString();
}

http://www.15seconds.com/issue/030806.htm

· .net CHARTING enables your web site to display massive amounts of dynamically generated data quickly and easily through a visual interface:

http://www.dotnetcharting.com/?15sd

· Creating Crystal Reports in c#.net:

http://www.codeproject.com/useritems/CreatingCrystalReports.asp

· XML Files:

http://www.codersource.net/csharp_xml_file_operations.html

http://www.eastasp.com/en-us/ebook/list.aspx?tagIndex=2&cat=ebook:devlanguage

· .NET Concepts

1. http://www.geekpedia.com/language5_Csharp.html

2. http://www.codersource.net/codersource_dot_net.html

· Menus in c#.net

§ http://search.msdn.microsoft.com/search/default.aspx?__VIEWSTATE=&query=creating+menus+using+c%23.net&siteid=0&tab=0

§ http://www.somacon.com/p142.php (CSS Color Chart)

· Menu Tools:

http://www.thefreecountry.com/programming/helpauthoring.shtml

· Help Files:

http://www.danish-shareware.dk/soft/shelpm/

· HTML:

http://www.obscure.org/~jaws/htmlhelp.html

· Building Grid using java script:

http://www.activewidgets.com/javascript.forum.4448.1/highlight-textbox-text.html

· Menus using javascript

http://dhtml-menu.com/dhtml-samples/menu615.html

http://www.webcredible.co.uk/user-friendly-resources/css/css-round-corners.shtml

· Read and Write Files using Javascript:

                                                                                            http://www.webreference.com/js/column71/index.html
               http://www.webreference.com/js/column55/index.html
 

· Menu Images:

1. http://www.cssplay.co.uk/menus/index.html

2. http://www.fg-a.com/backgrounds.htm

3. http://www.grsites.com/textures/

· https://cart.coffeecup.com/cart/

· Session Information:

http://support.microsoft.com/kb/307598/

• Data Set:

• 1. http://www.c-sharpcorner.com/Article/frmDisplayArticles.aspx?SectionID=1&SubSectionID=131

• Convert datagrid content to PDF:

http://www.scripts20.com/category/ASP_NET/Documents/1/0.html

• Tree View:

http://www.kiranreddys.com/csharp_faqs/02297266.html

• PL/SQL Programming:

http://www-db.stanford.edu/~ullman/fcdb/oracle/or-plsql.html#basic%20structure%20of%20pl/sql

• Sql Server:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/architec/8_ar_da_5b1v.asp