装箱与值类型虽然很容易理解，但是在实际使用中，并不总是能100%用对

    public struct Point 
    {
        private int m_x, m_y;

        public Point(int x, int y) 
        {
            m_x = x;
            m_y = y;
        }

        public override string ToString()
        {
            return string.Format("{0},{1}", m_x, m_y);
        }
    }

上面是一个值类型的定义，下面创建一个实例，用在控制台上输出一些信息：

            Point p = new Point(1, 1);
            Console.WriteLine(p);

这与

            Point p = new Point(1, 1);
            Console.WriteLine(p.ToString());

这二者在输出结果上完全一样，也许很多人象我一样，在平时工作中随意使用，也不会去管它有什么不同?

但其实，Console.WriteLine(p)是会产生装箱（box）指令的！

原因很简单：Console.WriteLine的所有重载版本中，并没有一个Console.WriteLine(Point p)的版本，所以默认会调用Console.WriteLine(Object o)这个版本，p会装箱成Object，返回一个在堆上的引用。

而Console.WriteLine(p.ToString())则会调用Console.WriteLine(String s)这个重载版本，p.ToString()已经是一个String了，所以无需装箱。

继续来看一段稍微长一点的代码:

using System;

namespace boxTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            test(5);
            Console.WriteLine(i);//1

            object obj = 1;           
            test(obj);
            Console.WriteLine(obj);//1

            string s = "1";
            test(s);
            Console.WriteLine(s);//"1"

            P1 p1 = new P1(1);
            test(p1);
            Console.WriteLine(p1.X);//1

            P2 p2 = new P2(1);
            test(p2);
            Console.WriteLine(p2.X);//5

            Console.Read();
        }

        static void test(int i)
        {
            i = 5;
        }

        static void test(object o)
        {
            o = 5;
        }

        static void test(string s)
        {
            s = "5";
        }

        static void test(P1 p)
        {
            p.X = 5;
        }

        static void test(P2 p) 
        {
            p.X = 5;
        }
    }

    internal struct P1
    {
        private int _x;

        public P1(int x)
        {
            _x = x;
        }
        public int X { set { _x = value; } get { return _x; } }
    }

    internal class P2
    {
        private int _x;

        public P2(int x)
        {
            _x = x;
        }
        public int X { set { _x = value; } get { return _x; } }
    }
}

上面代码的5次输出结果，您都猜对了吗？

第1次输出：因为i是值类型，参数传递默认是按值传递的，也就是说test方法体里的参数i是一个全新的副本，跟外界没关系，方法调用完后，方法体内的i自动被清理，不影响方法体外的i

第2次输出：虽然Object是引用类型，参数传递也是按引用传递的，但是方法体内o=5的赋值，使o指向了一个全新的"已装箱的5"，这时o与方法体外的obj已经是二个不同的对象了，有怀疑的同学，可用Object.ReferenceEquals方法输出验证，如下面这样

static void test(object o)
        {
            object o1 = o;
            Console.WriteLine(Object.ReferenceEquals(o1, o));//true
            o = 5;
            Console.WriteLine(Object.ReferenceEquals(o1, o));//false
        }

但是在test(Object o)调用完成后，main方法后面还要继续使用obj（因为有Console.WriteLine(obj)），所以obj此时也不会被列为垃圾回收的目标。test方法调用结束后，方法体内部的对象o，因不再使用将等候GC回收。

第3次输出：String虽然也是引用类型，但是String的处理机制有别于其它引用类型（这个话题展开就可再写一篇文章了，建议不清楚的同学去CLR VIR C#中的"字符、字符串和文本处理"相关内容），在test(String s)内对s赋值为新字符串时，同样会生成一个新的对象，因此也不会影响到test方法体外的值。但是：跟第2次输出不同的是，test(String s)调用结束后，字符串"5"却不会被立即回收（即：字符串驻留机制），如果下次有人需要再次使用字符串"5"，将直接返回这个对象的引用，这一点可通过观察对象的HashCode看出端倪：

using System;

namespace boxTest
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "1";
            test(s);           

            string s1 = "1";
            string s2 = "5";

            Console.WriteLine("{0},{1},{2}", s.GetHashCode(), s1.GetHashCode(), s2.GetHashCode());

            Console.Read();
        }

       

        static void test(string s)
        {
            Console.WriteLine("{0}", s.GetHashCode());
            s = "5";
            Console.WriteLine("{0}", s.GetHashCode());
        }        
    }    
}

输出结果为：

-842352753
-842352757
-842352753,-842352753,-842352757

第4次输出：struct类型的P1是值类型，类似第1次输出中的解释一样，按值传递，方法体内修改的只是副本的值，也不会影响test体外的值.

第5次输出：class类型的P2是引用类型，参数传递的其实是p2的地址(即指针)，而且在test方法体内并未对p2重新赋值(指没有类似p2 = new P2(1)类似的代码)，而只是修改了p2的属性X，方法调用结束后，p2引用指向的地址没有改变，但是这个地址中对应的值X已经变了，所以输出5.

最后再来二个CLR VIR C#原书示例的简化版

using System;

namespace boxTest
{
    class Program
    {
        static void Main(string[] args)
        {
            P p1 = new P(1);
            Console.WriteLine(p1);//1

            p1.ChangeX(2);
            Console.WriteLine(p1);//2

            object o = p1;
            ((P)o).ChangeX(5);
            Console.WriteLine(o);//这里将输出2，而不是5 ! 
            //解释：((P)o).ChangeX(5); 
            //其实相当于 P p2 = (P)o; p2.ChangeX(5);
            //所以根本没改变p1中的_x值(因为P是值类型，p2与p1在内存中对应的是二个不同的地址，相互并不干扰),
            //然后临时生成的p2因为不再被使用，Main方法执行完成后，会自动清理

            Console.Read();
        }         
    }

    struct P 
    {
        private int _x;

        public P(int i) 
        {
            _x = i;
        }        

        public void ChangeX(int x) 
        {
            _x = x;
        }

        public override string ToString()
        {
            return string.Format("{0}", _x);
        }
    }
}

 最后一次的输出，解释已经写在注释中了，大家自己体会。

using System;

namespace boxTest
{
    class Program
    {
        static void Main(string[] args)
        {
            P p1 = new P(1);
            Console.WriteLine(p1);//1

            p1.ChangeX(2);
            Console.WriteLine(p1);//2

            object o = p1;
            ((IChangeX)o).ChangeX(5);
            Console.WriteLine(o);//这里将输出5
            //解释: ((IChangeX)o).ChangeX(5); 相当于
            //IChangeX _temp = (IChangeX)o;
            //_temp.ChangeX(5);
            //因为接口实际上返回的是引用（算是引用类型），
            //所以这时_temp与o指向的是同一个内存地址，修改_temp就相当于修改o
           

            Console.Read();
        }         
    }

    struct P :IChangeX
    {
        private int _x;

        public P(int i) 
        {
            _x = i;
        }        

        public void ChangeX(int x) 
        {
            _x = x;
        }

        public override string ToString()
        {
            return string.Format("{0}", _x);
        }
    }

    interface IChangeX 
    {
        void ChangeX(int x);
    }
}

让struct实现一个接口以后，情况就变了，同样大家看注释，不解释。

 

要想写出高性能的代码，每个细节都要意识到背后发生的事情。所以象CLR VIR C#这类神作，没事拿来翻翻，不断加深印象还是很有必要的。