一个对C# 2.0 泛型性能的小实验引发的两个疑问

    最近开始学习C# 2.0,在查看C# 2.0 Language Specification(http://download.microsoft.com/download/8/1/6/81682478-4018-48fe-9e5e-f87a44af3db9/SpecificationVer2.doc)发现泛型如下问题:
规范对于泛型举了一个如下的例子:

public class Stack
{
    object[] items;
    int count;
    public void Push(object item) {}
    public object Pop() {}
}
.
.
.
Stack stack = new Stack();
stack.Push(3);
int i = (int)stack.Pop();

在这个普通的例子中,会执行box和unbox操作,并且在运行时会动态的检查类型,这样会影响性能(在一些blog上,有些兄弟用了"严重"两个字来形容).于是规范下面便接着举了一个使用泛型的例子(略).泛型不用执行box和unbox操作,并且不用在运行时动态检查,大大提高了性能.读到这里,我做了下面一个小实验,然后又修改实验代码,得到两个疑问.类似规范,我做了两个栈类.
一个普通栈:

class Stack
    {
        object[] items = new object[1000000];
        public int count = 0;

        public void Push(object item)
        {
            items[count++] = item;
        }
        public object Pop()
        {
            return items[--count];
        }
    }

一个泛型栈:

class GStack<T>
    {
        T[] items = new T[1000000];
        public int count = 0;

        public void Push(T item)
        {
            items[count++] = item;
        }
        public T Pop()
        {
            return items[--count];
        }
    }

程序主函数如下:

static void Main(string[] args)
        {
            DateTime normalBeginTime = DateTime.Now; 
            Stack normalStack = new Stack();//建立一个普通栈

            for (int i = 1; i <= 1000000; i++)
            {
                normalStack.Push(i); //将int植入栈,执行box操作
            }

            int normalCount = normalStack.count;
            while (normalCount > 0)
            {
                int item = (int)normalStack.Pop(); //将int出栈,执行unbox操作
                //Console.WriteLine(item.ToString());
                normalCount--;
            }

            DateTime normalEndTime = DateTime.Now;
            TimeSpan normalCostTime = normalEndTime - normalBeginTime; 
 
            DateTime genericBeginTime = DateTime.Now;
            GStack<int> genericStack = new GStack<int>(); //建立一个泛型栈

            for (int i = 1; i <= 1000000; i++)
            {
                genericStack.Push(i);
            }

            int genericCount = genericStack.count;
            while (genericCount > 0)
            {
                int item = genericStack.Pop();
                //Console.WriteLine(item.ToString());
                genericCount--;
            }

            DateTime genericEndTime = DateTime.Now;
            TimeSpan genericCostTime = genericEndTime - genericBeginTime;

            Console.WriteLine("Normal Type:" + normalCostTime.TotalMilliseconds);
            Console.WriteLine("Generic Type:" + genericCostTime.TotalMilliseconds);

            Console.Read();
        }

正如意料中那样,在这个例子中,执行完100W次出/入栈操作后,由于普通栈频繁的box/unbox操作,速度比使用泛型栈慢大概3-4倍.接着,我又做了下面试验,得出了两个疑问:
1.我将两个栈的大小改为100,每个出栈操作后紧跟一个打印,将出栈的值打印出来.这时候普通栈出/入栈100次的速度比泛型栈快了9-10倍，难道这两个栈出栈的int值有什么区别吗？(一个执行了unbox，一个没有？)
2.我将两个的大小改为1000W，但出/入栈次数都改为100次，这时，普通栈花费的时间几乎为0，而泛型栈花费了46毫秒左右。难道实例化泛型栈所花费的时间更多？为什么？

改来改去，代码被改得乱糟糟的，头也晕晕的，似乎有点钻牛角尖了，但还是写下来，希望哪位能指点一二，说不定从中能学到一些知识。：）