c#基础系列1---值类型和引用类型

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

基本概念

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

引用类型

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

值类型

因为引用类型变量都需要进行一次堆内存的分配，这会给GC造成很大的压力，所以CLR提供了轻量级类型“值类型”。 值类型一般在线程栈上分配。（注意：值类型可以嵌入一个引用对象中）一个值类型变量其实就包含了值类型实例的值，所以它没有引用类型的指针（大家猜想值类型需不需要类型对象指针呢？）

相同点和不同点

相同点

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

值类型和引用类型都可以继承接口。（很多人都认为值类型不能继承接口）

     throw new NotImplementedException();  
    }
}

不同点

1. 值类型分配在堆栈上，引用类型是在托管堆上分配的。这里需要指出一点：如果一个应用类型中的某个属性是值类型，这个值类型的属性是分配在托管堆上的。

2. 所有的值类型都是隐式密封的（sealed），例如 ：你不可能继承int 来构造自己的类型。

3. 值类型的每一次赋值都会执行一次逐字段的复制，所以如果是频繁赋值也会造成性能上的压力，引用类型的赋值只是指针的传递，其实也是生成新的指针实例。

4. 引用类型额外有类型对象指针和同步块索引，值类型是没有的。所以我们平时使用lock 锁的对象不可能是值类型，因为值类型没有同步块索引

性能

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

1. 值类型：所谓的.net Framework中的“轻量类型”，为什么说是“轻量”呢，这和他的内存分配有直接关系，因为值类型是分配在栈上，所以在GC的控制之外，不会对GC造成压力。那是不是可以随便用呢？当然不是，举个例子：我自定义一个struct 类型作为一个方法的参数会发生什么呢？每次调用都会发生全字段的赋值，这是不可接受的，这也是典型的值类型勿用场景。

2. 引用类型：引用类型分配在堆中，所以会影响GC，如果频繁的初始化引用类型，对GC的压力是很大的，因为每一次分配都有可能会强制执行一次垃圾收集操作。另外提一点，引用类型的所占内存，并非所有属性/字段的和，堆上分配的每个对象都有一些额外的成员，这些成员必须初始化。（类型对象指针和内存块索引）。

3. 装箱拆箱：所谓装箱就是将值类型转化为引用类型的过程。拆箱则相反（只是概念上相反，实际编译器的操作不一样）。有的同学说装箱拆箱影响性能，那到底是装箱影响呢还是拆箱呢还是都影响呢？

   1. 获取已经装箱的值类型实例的指针

   2. 把获取到的值复制到栈

   3. 在托管堆中分配好内存，分配的内存量是值类型的各个字段需要的内存量加上托管堆上所以对象的两个额外成员（类型对象指针，同步块索引）需要的内存量

   4. 值类型的字段复制到新分配的堆内存中

   5. 返回对象的地址，这个地址就是这个对象的引用

   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性质的，值类型或许是首选。

其他

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

2. 因为值类型有装箱拆箱的操作，所以像ArrayList这样的集合性能是非常令人担忧的。所以c# 2.0 出现了泛型 例如：List<T> .....来保证了类型安全，同时又避免了拆箱装箱，因为不是我定义的类型 ，你TMD根本连编译器那一关都过不了 哈哈哈~~~~