【基础中的基础】引用类型和值类型，以及引用传递和值传递_.NET_编程开发_程序员俱乐部

一直在博客园怼人，非常惭愧。所以郑重决定：

好好写一篇干货，然后再接着怼人。

这是一起帮上陈百万同学的求助，讲了一会之后，我觉得很有些普世价值，干脆就发到园子来。面向小白，高手轻拍。

我们从最简单的说起（基础知识，懂的同学直接往下拉），直接上代码：

class="brush:csharp;gutter:true;">        static int amount;
        static void AddTV(int amount)
        {
            amount++;
            Console.WriteLine("方法中，amount="+amount);
        }

然后，我们将参数amout传入AddTV()方法，希望能让其+1

            amount = 10;
            AddTV(amount);
            Console.WriteLine("AddTV(amount)执行之后，amount=" + amount);

 那么执行的结果呢？

amount的数量并没有发生变化。

为什么没有变呢？

这是最入门的知识，通常的解释是：

amount是int类型，int是值类型，所以当它作为参数时，传递给方法的是它的一个副本（复制品），因此方法中改变的是它的副本的值，amount本身并没有改变。

OK，这完全没有问题。而且，如果想改变的值，就需要加 ref 关键字，如下所示：

        static void AddTV(ref int amount)
        {
            amount++;
            Console.WriteLine("方法中，amount="+amount);
        }

大家自己跑一下，看看结果有什么不一样。

这叫做参数的引用传递。

这是最基础的知识，非常清晰。好的，接着，C#是面向对象的语言嘛，我们要引入一个对象。

    public class House
    {
        public int TVAmount { get; set; }
    }

然后，我们把House对象作为参数传递，值传递，不带ref的。如下所示：

        static void AddTV(House house)
        {
            house.TVAmount++;
            Console.WriteLine("方法中，house.TVAmount=" + house.TVAmount);
        }


            House house = new House();
            AddTV(house);
            Console.WriteLine("AddTV(house)执行之后，house.TVAmount=" + house.TVAmount);

执行之后你会发现：

咦？house.TVAmount的值变了耶！

为什么呢？

有的同学听到的解释是这样的：

House是对象，是引用类型，引用类型作为参数传递到方法中，它的值会被方法改变。

有些同学，哦！记住了：值类型传进去不变，引用类型传进去要变，但值类型引用传递又要变……虽然有点绕，但死背下来也行。

但有的同学就开始开始抛问题了：（这种同学特别值得表扬！安利一篇我的文章：讲课这些天（五）怎么才能把代码写好？）

值类型的引用传递，和引用类型的值传递，效果都一样，那他们有什么区别呢？

Good question！

实际上，死背上面的，是会出问题的，我还是用代码展示一下：

        static void AddTV(House house)
        {
            house = new House();
            house.TVAmount++;
            Console.WriteLine("方法中，house.TVAmount=" + house.TVAmount);
        }

这样写，眼尖的同学一眼就能看出差别：这一次方法体内多了一个：house = new House();

不要以为这是抽风啊，实际的开发代码中，各种各样的原因，很多时候都确实会在方法体内重新new一个参数实例的。

那运行结果怎么样的呢？

怎么样？！引用类型也不好使了？现在，是不是

不像JavaScript到处都是bug和设计缺陷（是的，日常黑js一百年，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" alt="">），C#是一门严谨清晰的语言，不会有什么“灵异”事件。现象和你的想法不一致，一定是你的想法出了问题。

所以，要真正地弄明白这里面的道道，我们还是要回到原点：

首先的首先，看看这代码，你真的明白是什么意思么：

            House house 
                = 
                new House();

我为什么要写成三行？

因为这其实是三个过程：

• House house 这是声明了一个变量
• new House() 这是生成了一个对象
• = 把 house 和 new House() 关联起来

注意，注意我用的是“关联”，很多人喜欢说“赋值”，甚至“等于”，这就容易造成我们理解上的误区。

为了理解这种关联，我画了一幅图：

观察这幅图，house和New House，是不同的数据储存。事实上，在house里面，有一个记录了new Houuse()存储位置的“引用”（reference，这个英文单词有助于我们理解）。所以，当我们house.TVAmount的时候，是通过house找到new House()，然后得到new House()的数据进行操作。

不知道大家能不能明白这一点？

作为对比，我们来看看值类型是怎么样子的。

整个这一块都是int i，int i 里面就直接的存储了10这个数据，没有引用，int i里直接存放数值10，所以叫做“值类型”。

好了，理解了上面的概念之后，我们回头来看方法参数。

C#的说法非常的清晰，只看有没有 ref 关键字：

1. 不带ref的，一定是“值传递”
2. 带ref的，一定是“引用传递”

和传递的是什么类型的参数，半毛钱关系没有。

关键是，你要知道：当参数为引用类型时，传递的不是对象（new House()），而是对象的引用(house)。

所以，

• 如果是值传递，传递的是 对象引用的 副本
• 如果是引用传递，传递的是 对象引用 本身

什么叫做对象引用的副本呢？还是给一幅图：

 明白了吧？作为参数的house的副本，还是指向的New House对象，所以，在方法体中使用：house.TVAmount++，最终修改的还是原来的new House()里面的值。

但是，当你在方法体中：house = new House(); 你实际上就干了件啥事呢？

然后，你再：house.TVAmount++，改变的是新的House对象的值啊！（请结合英文单词 new 来理解这一点）

所以，原来的 house 引用指向的对象，就根本没有发生改变。

希望你仍然还保持着清醒的头脑，没有被我弄晕，O(∩_∩)O~

这样我们就可以接着往下走。那假如我们既要保留方法体内的：house = new House(); 又要通过方法，改变传入对象的值，我应该怎么办呢？

……

干脆留作思考题吧？ o(￣┰￣*)ゞ 

请同学们在理解原理的基础上自己去写一写，跑一跑，仔细的体会体会。

最后，为了更清晰直观的看到所谓“对象的引用”的变化，我给大家一个神器：在调试时使用一元运算符 & 来查看变量的内存地址：

好了，自己折腾去吧！

enjoy it。

周末发帖，送给爱学习的同学们！

+++++++++++++++++++++++++++++++

最后，悄悄的说一句：我们的 一起帮 有了好多新功能，不想去看一看？