c#基础系列1---深刻理解值类型和引用类型

“大菜”：源于本身刚踏入猿途混沌拾起，自我感受不是通常的菜，于是得名“大菜”，于自身共勉。

不知不觉已经踏入坑已10余年之多，对于c#多多少少有一点本身的认识，写出来渴求同类抨击，对本身也算是个十年之痒的一个总结。据说有美女图点赞的人多

基本概念

CLR支持两种类型：值类型和引用类型。 面试过不少5年左右的同窗，有不少连值类型和引用类型的基本概念都回答不上来，难道如今的c#开发人员基础这么弱了吗？仍是你们都不重视基础呢？这个随便找一篇博客均可以基础入门的。

引用类型

哪些类型是引用类型呢？其实一个能够称为”类“的类型都是引用类型。 引用类型老是从托管堆上分配的，经常使用的语法就是New XX(). C#的new 操做符会返回对象的指针 - 也就是指向对象数据的内存地址的一个引用。引用类型的传递其实传递的是对象的指针（string类型比较特殊），因此在特定的场景下性能是高于值类型的。一个引用类型在建立时默认为null，也就是说当前变量不指向一个有效的对象，也就是咱们常遇到的异常“未将对象引用设置到对象的实例”。

值类型

由于引用类型变量都须要进行一次堆内存的分配，这会给GC形成很大的压力，因此CLR提供了轻量级类型“值类型”。 值类型通常在线程栈上分配。（注意：值类型能够嵌入一个引用对象中）一个值类型变量其实就包含了值类型实例的值，因此它没有引用类型的指针（你们猜测值类型需不须要类型对象指针呢？）

相同点和不一样点

相同点

1. 值类型和引用类型都是System.Object的子类

2. 值类型和引用类型均可以继承接口。（不少人都认为值类型不能继承接口）

   interface Itest
    {
        void test();
    }
    struct TestStruct : Itest
    {
        public void test()
        {
            throw new NotImplementedException();
        }
    }

不一样点

1. 值类型分配在堆栈上，引用类型是在托管堆上分配的。这里须要指出一点：若是一个引用类型中的某个属性是值类型，这个值类型的属性是分配在托管堆上的。
2. 全部的值类型都是隐式密封的（sealed），例如 ：你不可能继承int 来构造本身的类型。
3. 值类型的每一次赋值都会执行一次逐字段的复制，因此若是是频繁赋值也会形成性能上的压力，引用类型的赋值只是指针的传递，其实也是生成新的指针实例。
4. 引用类型额外有类型对象指针和同步块索引，值类型是没有的。因此咱们平时使用lock 锁的对象不多是值类型，由于值类型没有同步块索引

性能

有的同窗说值类型的性能高于引用类型，那为何不都用值类型呢？引用类型也是如此。任何东西都有两面性，只有合适的类型，没有万能的类型。

1. 值类型：所谓的.net Framework中的“轻量类型”，为何说是“轻量”呢，这和他的内存分配有直接关系，由于值类型是分配在栈上，因此在GC的控制以外，不会对GC形成压力。那是否是能够随便用呢？固然不是，举个例子：我自定义一个struct 类型做为一个方法的参数会发生什么呢？每次调用都会发生全字段的赋值，这是不可接受的，这也是典型的值类型勿用场景。
2. 引用类型：引用类型分配在堆中，因此会影响GC，若是频繁的初始化引用类型，对GC的压力是很大的，由于每一次分配都有可能会强制执行一次垃圾收集操做。另外提一点，引用类型的所占内存，并不是全部属性/字段的和，堆上分配的每一个对象都有一些额外的成员，这些成员必须初始化。（类型对象指针和内存块索引）。
3. 装箱拆箱：所谓装箱就是将值类型转化为引用类型的过程。拆箱则相反（只是概念上相反，实际编译器的操做不同）。有的同窗说装箱拆箱影响性能，那究竟是装箱影响呢仍是拆箱呢仍是都影响呢？
   1. 装箱发生了什么过程呢：
      1. 在托管堆中分配好内存，分配的内存量是值类型的各个字段须要的内存量加上托管堆上因此对象的两个额外成员（类型对象指针，同步块索引）须要的内存量
      2. 值类型的字段复制到新分配的堆内存中
      3. 返回对象的地址，这个地址就是这个对象的引用
   2. 拆箱发生了什么过程呢：
      1. 获取已经装箱的值类型实例的指针
      2. 把获取到的值复制到栈

因此装箱是比较耗费性能的，还有可能引起一次GC操做，而拆箱只是一个获取指针的过程耗费资源要比装箱小的多。注意：一个对象拆箱以后只能还原为原先未装箱以前的类型，例如：你不能把int32类型装箱后还原为int16类型。 因此面试的时候能够和面试官装B一下了~~

测试例子

值类型引用类型分别初始化N次消耗的时间，代码以下

static void Main(string[] args)
    {
        Console.WriteLine("test start");
        int totalCount = 10000000;
        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < totalCount; i++)
        {
            TestRef temp = new TestRef() { Id = i, Name = "test" };
        }
        sw.Stop();
        Console.WriteLine($"引用类型耗时:{sw.ElapsedMilliseconds}");
        sw.Reset();
        sw.Start();

        for (int i = 0; i < totalCount; i++)
        {
            TestVal temp = new TestVal() { Id = i, Name = "test" };
        }
        sw.Stop();
        Console.WriteLine($"值类型耗时:{sw.ElapsedMilliseconds}");
        Console.Read();
    }

    class TestRef
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
    struct TestVal
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

运行结果：

引用类型耗时:205
值类型耗时:152

可见初始化速度值类型是优于引用类型的，也多是引用类型引起了GC致使。

做为方法参数传递，代码以下：

static void Main(string[] args)
    {
        Console.WriteLine("test start");
        long totalCount = 1000000000;
        Stopwatch sw = new Stopwatch();
        sw.Start();

        TestRef tempRef = new TestRef() { Id = 1, Name = "test" , Name2="r3rewfdsafdsa", Name3="fsrewfdsafdsafdsa", Name4="fdafdasfdsafdsa", Name5="432tretsfds", Name6="fdsafdasfdasfd" };
        for (int i = 0; i < totalCount; i++)
        {
            TestR(tempRef);
        }
        sw.Stop();
        Console.WriteLine($"引用类型耗时:{sw.ElapsedMilliseconds}");
        sw.Reset();
        sw.Start();
        TestVal tempVal = new TestVal() { Id = 1, Name = "test", Name2 = "r3rewfdsafdsa", Name3 = "fsrewfdsafdsafdsa", Name4 = "fdafdasfdsafdsa", Name5 = "432tretsfds", Name6 = "fdsafdasfdasfd" };
        for (int i = 0; i < totalCount; i++)
        {
            TestV(tempVal);
        }
        sw.Stop();
        Console.WriteLine($"值类型耗时:{sw.ElapsedMilliseconds}");
        Console.Read();
    }
    static void TestR(TestRef r)
    {
        return;
    }
    static void TestV(TestVal v)
    {
        return;
    }

    class TestRef
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Name2 { get; set; }
        public string Name3 { get; set; }
        public string Name4 { get; set; }
        public string Name5 { get; set; }
        public string Name6 { get; set; }
    }
    struct TestVal
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Name2 { get; set; }
        public string Name3 { get; set; }
        public string Name4 { get; set; }
        public string Name5 { get; set; }
        public string Name6 { get; set; }
    }

运行结果：

引用类型耗时:4437
值类型耗时:5226

可见在普通状况下，做为参数值类型和引用类型用时差距不大，可是，若是值类型的实例属性比较多的状况下差距降进一步拉大。

非正式环境测试用例，结果仅供参考

应用场景

不止是面试的时候常常问应用场景这个问题，就是本身平时写程序也应该清楚。程序设计选择的时候大部分场景都是用引用类型，可是若是你知足下列条件，值类型可能更适用：

1. 类型不会派生出任何其它类型，也就是说不会有被继承的可能
2. 类型不须要继承其余类型
3. 类型的实例比较小，而且不会被做为方法参数，不会被频繁赋值
4. 你永远不会用到类型释放时候的通知，由于引用类型利用析构函数能够利用其余手段能够获得释放时候的通知。

5. 若是你的类型实例不会发生值的改变或者能够认为是readonly性质的，值类型或许是首选。

   其余

6. 全部的值类型都从System.ValueType 派生，System.ValueType继承System.Object,可是System.ValueType 重写了Equals 和GetHashCode 方法，其实在这里才是真正和引用类型的分割线。

7. 由于值类型有装箱拆箱的操做，因此像ArrayList这样的集合性能是很是使人担心的。因此c# 2.0 出现了泛型 例如：List .....来保证了类型安全，同时又避免了拆箱装箱，由于不是我定义的类型 ，你TMD根本连编译器那一关都过不了 哈哈哈~~~~

顺便说一句，很久不写博客，样式真实花时间啊，后来干脆写markdown格式的，请你们见谅！！

请尊重一个猿的辛苦，转载请标明出处 ^ ~ ^  。部分图片来源于网络，若是侵权请及时联系我。让咱们一块儿进步吧

一个不止于IT圈内容的微信公众号，欢迎关注，交流更多的IT知识。不定时会有惊喜奥 ^ ~ ^