值类型和引用类型

用几个案例来解释值类型和引用类型

首先看值类型，案例如下：

案例一：

static void Main(string[] args)
        {
            int n = 10;
            M1(n);
            Console.WriteLine(n);//10
            Console.ReadKey();
        }

        private static void M1(int m)
        {
            m++;
        }

解释：第一次声明变量n，会在栈中开辟一块空间，我们自己命名为n，赋值后，空间中就存了10.调用方法的时候，把n传给方法，相当于把n赋值给m，所以m变成10,然后执行方法内部的代码（m++），此时m=11。但是我们要输出的变量是n，所以结果仍然是10.

案例二：

static void Main(string[] args)
        {
            #region 案例一
            //int n = 10;
            //M1(n);
            //Console.WriteLine(n);//10
            #endregion

            #region 案例一
            Person p = new Person();
            p.Age = 100;
            M2(p);
            Console.WriteLine(p.Age);//101
            #endregion

            Console.ReadKey();
        }

        private static void M2(Person p1)
        {
            p1.Age++;
        }

解释：Person p=new Person();首先在堆中开辟一块空间，保存person对象，给Age赋值为100，这块堆的内存名称为x00x32，保存在栈中，对应的栈名称我们取名为p。当调用M2()方法的时候，我们重新声明了一个变量p1,并且把p赋给p1（变量都是值类型）,等效于把栈中的值复制一份存入p1这块栈中，所以p,p1都指向x00x32这块内存，执行方法中的代码后，p.Age，p1.Age都为101。

案例三：

class Program
    {
        static void Main(string[] args)
        {
            #region 案例一
            //int n = 10;
            //M1(n);
            //Console.WriteLine(n);//10
            #endregion

            #region 案例二
            //Person p = new Person();
            //p.Age = 100;
            //M2(p);
            //Console.WriteLine(p.Age);//101
            #endregion

            #region 案例三
            Person p = new Person();
            p.Age = 100;
            M3(p);
            Console.WriteLine(p.Age);//
            #endregion


            Console.ReadKey();
        }

        private static void M3(Person p1)
        {
            p1.Age = 1000;
            p1 = new Person();
            p1.Age = 200;
        }

        private static void M2(Person p1)
        {
            p1.Age++;
        }

结果为1000.

案例四：

static void Main(string[] args)
        {
            #region 案例一
            //int n = 10;
            //M1(n);
            //Console.WriteLine(n);//10
            #endregion

            #region 案例二
            //Person p = new Person();
            //p.Age = 100;
            //M2(p);
            //Console.WriteLine(p.Age);//101
            #endregion

            #region 案例三
            //Person p = new Person();
            //p.Age = 100;
            //M3(p);
            //Console.WriteLine(p.Age);//1000
            #endregion

            #region 案例四
            Person p = new Person();
            p.Age = 100;
            M4(p);
            Console.WriteLine(p.Age);//100
            #endregion

            Console.ReadKey();
        }

        private static void M4(Person p1)
        {
            p1 = new Person();
            p1.Age++;
        }

Person p=new Person();在堆中开辟一块空间x001,Age=100,把堆的名称x001保存到栈中，栈中开辟的空间（实际的名称没显示）我们自己命名为p。调用方法时，又在栈中开辟了一块空间，我们自己命名为p1,然后把p1赋值给p，由于变量名称都是值类型，所以直接把p中x001拷贝一份给p1，这时候p,p1都指向x001这块堆空间。接下来执行方法中的代码的时候，又在堆中开辟了一块空间x002（类成员Age的初始默认值为0，p1.Age++后为1）,然后赋值给p1,这时候，p1中保存堆名称变成x002了.但是我们输出的是p.Age，所以仍然是100.

案例五：

     {
            #region 案例五
            string name = "科比";
            M5(name);
            Console.WriteLine(name);//科比
            #endregion

            Console.ReadKey();
        }

        private static void M5(string name1)
        {
            name1 = "乔丹";
        }        

注意：变量都是值类型的，存在栈中 。

案例六：

    {
            #region 案例六
            int[] arrInt = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            M6(arrInt);
            //??????????
            for (int i = 0; i < arrInt.Length; i++)
            {
                Console.WriteLine(arrInt[i]);//1,2,3,4,5,6,7,8
            }
            #endregion

            Console.ReadKey();
        }

        private static void M6(int[] arrInt1)
        {
            arrInt1 = new int[arrInt1.Length];
            for (int i = 0; i < arrInt1.Length; i++)
            {
                arrInt1[i] = arrInt1[i] * 2;
            }
        }        

int[] arrInt = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };先在堆中开辟一块空间x001,并且初始化数组。栈中开辟的空间保存x001,我们自己把栈中空间命名为arrInt，调用方法的时候，声明了变量arrInt1,在栈中又开辟了一块空间x002,我们命名为arrInt1,然后把arrInt赋值给arrInt1,因为变量都是值类型，所以直接把栈的内容拷贝一份到arrInt1中，此时arrInt,arrInt2都指向x001这块内存。接下来执行方法中的代码。在M6方法中，先在堆中开辟了一块空间x002，指定了数组的长度，但是没有初始化，由于是int类型，所以数组的所有元素都是0,然后把x002保存到栈中，此时arrInt1就不再指向x001，而是指向了x002，最后操作数组arrInt1。我们需要输出的是arrInt,所以最后的值是1，2，3，4，5，6，7，8。

案例七：

{
            #region 案例七
            int[] arrInt = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            M7(arrInt);
            //??????????
            for (int i = 0; i < arrInt.Length; i++)
            {
                Console.WriteLine(arrInt[i]);
            }
            #endregion

            Console.ReadKey();
        }

        private static void M7(int[] arrInt1)
        {
            for (int i = 0; i < arrInt1.Length; i++)
            {
                arrInt1[i] = 100;
            }
        }        

接下来我们把上面的方法全部改成引用传递，看看有什么异同。

案例一：

  #region 案例一
            int n = 10;
            M1(ref n);
            Console.WriteLine(n);
            #endregion

private static void M1(ref int m)
        {
            m++;
        }

 int n=10；在栈中开辟一块空间x001,存入10，我们给这块空间的名称重新命名为n,值传递会把内存中的东西（不管保存的是内容还是地址）拷贝一份，引用传递传递的是电脑给内存分配的地址x001,所以值传递等效于我们给x001这个地址又重新起了个名字m, m,n都对应x001这个内存名称，x001对应分配的内存，但是m,n都不保存。所以m++后，n也会变。（至于m,n为什么不保存需要研究）。所以最终输出11.

把代码转换为IL语言后，发现内存中是不存在m,n变量的，只有内存地址，程序是根据内存地址读取数据的。

所以值传递传递的是栈中内容，对于值类型，栈中的类型就是栈中的数据，对于引用类型，栈中的内容就是对象的地址。引用传递传递的是栈本身的地址，多个变量名实际上指向的是同一个栈变量。

 案例二：

            #region 案例二
            Person p = new Person();
            p.Age = 100;
            M2(ref p);
            Console.WriteLine(p.Age);//101
            #endregion

private static void M2(ref Person p1)
        {
            p1.Age++;
        }

结果是101；

案例三：

#region 案例三
            Person p = new Person();
            p.Age = 100;
            M3(ref p);
            Console.WriteLine(p.Age);//
            #endregion

private static void M3(ref Person p1)
        {
            p1.Age = 1000;
            p1 = new Person();
            p1.Age = 200;
        }

Person p=new Person();在堆中开辟一块空间x001，Age=100,保存在栈中，栈这块内存地址是y001，里面保存的内容是x001，我们自己命名为p,调用方法时，采用引用传递，只是给栈的地址换了个别名,改为p1,p,p1还是指向栈中y001这块内存。执行方法后，在堆中重新分配了块内存x002,并且赋值给p1,所以栈中x001这块内存中存的内容变成x002，然后改变Age=200，到这里实际上p，p1都指向了x002这块内存，所以最终的结果为200.

案例四：

 #region 案例四
            Person p = new Person();
            p.Age = 100;
            M4(ref p);
            Console.WriteLine(p.Age);//
            #endregion

private static void M4(ref Person p1)
        {
            p1 = new Person();
            p1.Age++;
        }

结果：1；

案例五：

#region 案例五
            string name = "科比";
            M5(ref name);
            Console.WriteLine(name);//
            #endregion

private static void M5(ref string name1)
        {
            name1 = "乔丹";
        }

结果是：乔丹

案例六：

 int[] arrInt = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            M6(ref arrInt);
            //??????????
            for (int i = 0; i < arrInt.Length; i++)
            {
                Console.WriteLine(arrInt[i]);//
            }

private static void M6(ref int[] arrInt1)
        {
            arrInt1 = new int[arrInt1.Length];
            for (int i = 0; i < arrInt1.Length; i++)
            {
                arrInt1[i] = arrInt1[i] * 2;
            }
        }

结果全部是0；

案例七：

 #region 案例七
            int[] arrInt = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            M7(ref arrInt);
            //??????????
            for (int i = 0; i < arrInt.Length; i++)
            {
                Console.WriteLine(arrInt[i]);
            }
            #endregion

 private static void M7(ref int[] arrInt1)
        {
            for (int i = 0; i < arrInt1.Length; i++)
            {
                arrInt1[i] = 100;
            }
        }

全部是100