Programming .NET Components, 2nd Edition

Generics Problem Statement

Consider an everyday data structure such as a stack, providing the classic Push() and Pop() methods. When you develop a general-purpose stack, you would probably like to use it to store instances of various types. Under C# 1.1, you have to use an object-based stack, meaning that the internal data type used in the stack is an amorphous object, and the stack methods interact with objects:

    public class Stack
    {
       object[] m_Items;
       public void Push(object item)
       {...}
       public object Pop()
       {...}
    }

Example D-1 shows the full implementation of the object-based stack.

Example D-1. An object-based stack

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

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

Because object is the canonical .NET base type, you can use the object-based stack to hold any type of items, such as integers:

    Stack stack = new Stack();
    stack.Push(1);
    stack.Push(2);
    int number = (int)stack.Pop();

However, there are two problems with object-based solutions. The first issue is performance. ...