Programming .NET Components, 2nd Edition

What Are Generics?

Generics allow you to define type-safe classes without compromising type safety, performance, or productivity. You implement the server only once as a generic server, while at the same time you can declare and use it with any type. To do that, use the < and > brackets, enclosing a generic type parameter. For example, here is how you define and use a generic stack:

    public class Stack<T>
    {
       T[] m_Items;
       public void Push(T item)
       {...}
       public T Pop()
       {...}
    }
    Stack<int> stack = new Stack<int>();
    stack.Push(1);
    stack.Push(2);
    int number = stack.Pop();

Example D-2 shows the full implementation of the generic stack.

Example D-2. The generic stack

public class Stack<T>
{
   const int DefaultSize = 100;
   readonly int m_Size;
   int m_StackPointer = 0;
   T[] m_Items;

   public Stack() : this(DefaultSize)
   {}
   public Stack(int size)
   {
      m_Size = size;
      m_Items = new T[m_Size];
   }
   public void Push(T item)
   {
      if(m_StackPointer >= m_Size)
      {
         throw new StackOverflowException();
      }
      m_Items[m_StackPointer] = item;
      m_StackPointer++;
   }
   public T Pop()
   {
      m_StackPointer--;
      if(m_StackPointer >= 0)
      {
         return m_Items[m_StackPointer];
      }
      else
      {
         m_StackPointer = 0;
         throw new InvalidOperationException("Cannot pop an empty stack");
      }
   }
}

Example D-2 is the same as Example D-1, except that in Example D-2 every use of object has been replaced with T, and the Stack is defined using the generic type parameter T:

    public class Stack<T>
    {...}

When you use the generic stack, you have to instruct the compiler which type to ...