欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

c#中的值类型和引用类型 装箱拆箱 (好文)

程序员文章站 2022-05-06 09:33:14
...

 

一,c#中的值类型和引用类型

     众所周知在c#中有两种基本类型,它们分别是值类型和引用类型;而每种类型都可以细分为如下类型:

    c#中的值类型和引用类型 装箱拆箱 (好文)

  1.  什么是值类型和引用类型
    • 什么是值类型:
      • 进一步研究文档,你会发现所有的结构都是抽象类型System.ValueType的直接派生类,而System.ValueType本身又是直接从System.Object派生的。根据定义所知,所有的值类型都必须从System.ValueType派生,所有的枚举都从System.Enum抽象类派生,而后者又从System.ValueType派生。  
      •  所有的值类型都是隐式密封的(sealed),目的是防止其他任何类型从值类型进行派生。       
    • 什么是引用类型:
      • 在c#中所有的类都是引用类型,包括接口。
  2.  区别和性能
    • 区别:
      • 值类型通常被人们称为轻量级的类型,因为在大多数情况下,值类型的的实例都分配在线程栈中,因此它不受垃圾回收的控制,缓解了托管堆中的压力,减少了应用程序的垃圾回收的次数,提高性能。
      • 所有的引用类型的实例都分配在托管堆上,c#中new操作符会返回一个内存地址指向当前的对象。所以当你在创建个一个引用类型实例的时候,你必须要考虑以下问题:
        • 内存是在托管堆上分配的
        • 在分配每一个对象时都会包含一些额外的成员(类型对象指针,同步块索引),这些成员必须初始化
        • 对象中的其他字节总是设为零
        • 在分配对象时,可能会进行一次垃圾回收操作(如果托管堆上的内存不够分配一次对象时)
    • 性能:
      • 在设计一个应用程序时,如果都是应用类型,那么应用程序的性能将显著下降,因为这会加大托管堆的压力,增加垃圾回收的次数。
      • 虽然值类型是一个轻量级的类型,但是如果大量的使用值类型的话,也会有损应用程序的性能(例如下面要讲的装箱和拆箱操作,传递实例较大的值类型,或者返回较大的值类型实例)。
      • 由于值类型实例的值是自己本身,而引用类型的实例的值是一个引用,所以如果将一个值类型的变量赋值给另一个值类型的变量,会执行一次逐字段的复制,将引用类型的变量赋值给另一个引用类型的变量时,只需要复制内存地址,所以在对大对象进行赋值时要避免使用值类型。例如下面的代码

        c#中的值类型和引用类型 装箱拆箱 (好文)

         1  class SomRef
         2     {
         3         public int x;
         4     }
         5     struct SomeVal {
         6         public int x;
         7     }
         8     class Program {
         9         static void ValueTypeDemo() {
        10             SomRef r1 = new SomRef();//在堆上分配
        11             SomeVal v1 = new SomeVal();//在栈上分配
        12             r1.x = 5;//提领指针
        13             v1.x = 5;//在栈上修改
        14             SomRef r2 = r1;//只复制引用(指针)
        15             SomeVal v2 = v1;//在栈上分配并复制成员
        16         }
        17     }

        c#中的值类型和引用类型 装箱拆箱 (好文)

        c#中的值类型和引用类型 装箱拆箱 (好文)

  3. 常见误区
    • 引用类型分配在托管堆上,值类型分配在线程栈上:其实这种说法的前半部分是对的,后半部分是错的。因为变量的值在它声明的位置存储的,所以假如某一个引用类型中有一个值类型的变量, 那么该变量的值总是和该引用类型的对象的其它数据在一起,也就是分配在堆上。(只有局部变量(方法内部声明的变量)和方法的参数在栈上)
    • 结构是轻量级的类:这种错误的信息主要是因为有人认为值类型不应该有方法或者其它有意义的行为-它们应该作为简单的数据转移来使用,所以很多人分不清DateTime到底是值类型还是引用类型
    • 对象在c#中默认的是用引用传递的其实在调用方法的时候,参数值(对象的一个引用)是以传值得方式传递的,如果你想以引用方式传递的话,可以使用ref或者out关键字。

二,值类型的装箱和拆箱操作

1 int i = 5;
2 object o = i;
3 int j = (int)o;
4 Int16 y=(Int16)o;

 

  1.  什么是装箱,什么是拆箱
    • 什么是装箱:所谓装箱就是将值类型转化为引用类型的过程(例如上面代码的第2行),在装箱时,你需要知道编译器内部都干了什么事:
      • 在托管堆中分配好内存,分配的内存量是值类型的各个字段需要的内存量加上托管堆上所以对象的两个额外成员(类型对象指针,同步块索引)需要的内存量
      • 值类型的字段复制到新分配的堆内存中
      • 返回对象的地址,这个地址就是这个对象的引用
    • 什么是装箱:将已装箱的值类型实例(此时它已经是引用类型了)转化成值类型的过程(例如上面代码的第3行),注意:拆箱不是直接将装箱过程倒过来,拆箱的代价比装箱要低的多,拆箱其实就是获取一个指针的过程。一个已装箱的实例在拆箱时,编译器在内部都干了下面这些事:
      • 如果包含了“对已装箱类型的实例引用”的变量为null时,会抛出一个NullReferenceException异常。
      • 如果引用指向的对象不是所期待的值类型的一个已装箱实例,会抛出一个InvalidCastException异常(例如上面代码的第4行)。  
  1.  它们在什么情况下发生,以及如何避免
  2. c#中的值类型和引用类型 装箱拆箱 (好文)

    1    static void Main(string[] args)
    2         {
    3             int v = 5;
    4             object o = v;
    5             v = 123;
    6             Console.WriteLine(v+","+(int)o);
    7        }

    c#中的值类型和引用类型 装箱拆箱 (好文)

          通过上面的分析我们已经知道了,装箱和拆箱/复制操作会对应用程序的速度和内存消耗产生不利的影响(例如消耗内存,增加垃圾回收次数,复制操作),所以我们应该注意编译器在什么时候会生成代码来自动这些操作,并尝试手写这些代码,尽量避免自动生成代码的情况。

    • 你能一眼从上面的代码中看出进行了几次装箱操作吗?正取答案是3次。分别进行了哪三次呢,我们来看一下:第一次object o=v;第二次在执行 Console.WriteLine(v+","+(int)o);时将v进行装箱,然后对o进行拆箱后又装箱。也就是说装箱过程总是在我们不经意的时候进行的,所以只有我们充分了解了装箱的内部机制,才能有效的避免装箱操作,从而提高应用程序的性能。所以对上面的代码进行如下修改可以减少装箱次数,从而提高性能:

      c#中的值类型和引用类型 装箱拆箱 (好文)

      1  static void Main(string[] args)
      2         {
      3             int v = 5;
      4             object o = v;
      5             v = 123;
      6             Console.WriteLine(v.ToString() + "," + ((int)o).ToString());//((int)o).ToString()代码本身没有任何意义,只为演示装箱和拆箱操作
      7        }

      c#中的值类型和引用类型 装箱拆箱 (好文)

    • 下面来讨论一下编译器都会在什么时候自动生成代码来完成这些操作
      • 使用非泛型集合时:比如ArrayList,因为这些集合需要的对象都是object,如果你将一个值类型的对象添加到集合中时会执行一次装箱操作,当你取值时会执行一次拆箱操作,所以在应用程序中应避免使用这种非泛型的集合。
      • 大家都知道System.Object是所有类型的基类,当你调用object类型的非虚方法时会进行装箱操作(例如GetType方法)。在调用object的虚方法时,如果你的值类型没有重写虚方法也要进行装箱操作,所以在定义自己的值类型时,应重写object内部的虚方法(例如ToString方式)
      • 将值类型转化为接口类型时也会进行装箱操作,这是因为接口类型必须包含对堆上的一个对象的引用。

三,泛型的出现(本节只简单介绍泛型对装箱和拆箱所起的作用,关于泛型的具体细节请参考下一篇文章)

    •  什么泛型
      • 泛型是CLR和编程语言提供的一种特殊机制,它在c#2中才被提供出来。
    •  它对避免装箱有什么作用?
      • 在使用泛型时需要指定要装配的类型,这样可以减少装箱操作,比如下面的代码

        c#中的值类型和引用类型 装箱拆箱 (好文)

         1   static void Main(string[] args)
         2         {
         3             ArrayList dateList = new ArrayList { 
         4             DateTime.Now
         5             };
         6 
         7             IList<DateTime> dateT = new List<DateTime> { 
         8             DateTime.Now
         9             };
        10         }

        c#中的值类型和引用类型 装箱拆箱 (好文)

        使用ArrayList时,每添加一个时间都会进行一次装箱操作,而使用List<DateTime>时就不会进行装箱操作,从而提高应用程序的性能。

    •  C#中常见的泛型集合:

      Queue<T>;

      Stack<T>;

      List<T>;

      Dictionary<Tkey,Tvalue>;

      HashSet<T>;

       

       在使用这些集合之前我们必须要理解每一种集合的工作原理(没事自己可以实现一下),了解每一种集合的适合场合,这样才能写出高效的代码。

四,在设计时如何选择类和结构体

在面试的时候,我们经常被问的一个问题(还有另外一个问题,如何选择抽象类和接口,下次我会单独聊聊这个问题),下面我们来聊聊在设计时应该如何选择结构体和类

    •  什么是结构体
      • 结构体是一种特殊的值类型,所以它拥有值类型所以的特权(实例一般分配在线程栈上)和限制(不能被派生,所以没有 abstract 和 sealed,未装箱的实例不能进行线程同步的访问)。
    •  什么情况下选择结构体,什么情况下选择类
      • 在大多数的情况下,都应该选择类,除非满足以下情况,才考虑选择结构体:
      • 类型具有基元类型的行为
      • 类型不需要从其它任何类型继承
      • 类型也不会派生出任何其它类型
      • 类型的实例较小(约为16字节或者更小)
      • 类型的实例较大,但是不作为方法的参数传递,也不作为方法的返回值。

都说程序是一门注重实践的学科,但是也只有熟悉理解了这些概论的东西,才能在实践时写出优秀的代码,有不对或者不合理的地方欢迎在下面讨论;

https://www.cnblogs.com/bakuhert/articles/5878086.html

什么是值类型,什么是引用类型

 

概念:值类型直接存储其值,而引用类型存储对其值的引用。部署:托管堆上部署了所有引用类型。

 

引用类型:基类为Objcet

值类型:均隐式派生自System.ValueType:

 

值类型:

byte,short,int,long,float,double,decimal,char,bool 和 struct 统称为值类型。

引用类型:

string 和 class统称为引用类型。

 

  • 值类型变量声明后,不管是否已经赋值,编译器为其分配内存。
  • 引用类型当声明一个类时,只在栈中分配一小片内存用于容纳一个地址,而此时并没有为其分配堆上的内存空间。当使用 new 创建一个类的实例时,分配堆上的空间,并把堆上空间的地址保存到栈上分配的小片空间中。
  • 值类型的实例通常是在线程栈上分配的(静态分配),但是在某些情形下可以存储在堆中。
  • 引用类型的对象总是在进程堆中分配(动态分配)。

我们来看下面一段代码:

c#中的值类型和引用类型 装箱拆箱 (好文)

输出结果:

 c#中的值类型和引用类型 装箱拆箱 (好文)

c#中的值类型和引用类型 装箱拆箱 (好文)

值类型在栈内分配空间大小因变量类型而异;

引用类型在栈内的空间大小相同;

 

1. 通用类型系统

C#中,变量是值还是引用仅取决于其数据类型。

C#的基本数据类型都以平台无关的方式来定义。C#的预定义类型并没有内置于语言中,而是内置于.NET Framework中。.NET使用通用类型系统(CTS)定义了可以在中间语言(IL)中使用的预定义数据类型,所有面向.NET的语言都最终被编译为IL,即编译为基于CTS类型的代码。

例如,在C#中声明一个int变量时,声明的实际上是CTS中System.Int32的一个实例。这具有重要的意义:

  • 确保IL上的强制类型安全;
  • 实现了不同.NET语言的互操作性;
  • 所有的数据类型都是对象。它们可以有方法,属性,等。例如:

int i;

i = 1;

string s;

s = i.ToString();

 

以下关系图(来自MSDN)说明了这几种类型是如何相关的。注意,类型的实例可以只是值类型或自描述类型,即使这些类型有子类别也是如此。

类型类别:

 c#中的值类型和引用类型 装箱拆箱 (好文)

2.值类型

C#的所有值类型均隐式派生自System.ValueType:

结构体:struct(直接派生于System.ValueType);

数值类型:

整型:sbyte(System.SByte的别名),short(System.Int16),int(System.Int32),long(System.Int64),byte(System.Byte),ushort(System.UInt16),uint(System.UInt32),ulong(System.UInt64),char(System.Char);

浮点型:float(System.Single),double(System.Double);

用于财务计算的高精度decimal型:decimal(System.Decimal)。

bool:bool(System.Boolean的别名);

用户定义的结构体(派生于System.ValueType)。

枚举:enum(派生于System.Enum);

可空类型(派生于System.Nullable<T>泛型结构体,T?实际上是System.Nullable<T>的别名)。

每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如:

int i = new int();

等价于:

Int32 i = new Int32();

等价于:

int i = 0;

等价于:

Int32 i = 0;

引用类型和值类型都继承自System.Object类。不同的是,几乎所有的引用类型都直接从System.Object继承,而值类型则继承其子类,即 直接继承System.ValueType。System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型,而不是值类型。其关键在于ValueType重写了Equals()方法,从而对值类型按照实例的值来比较,而不是引用地址来比较。

可以用Type.IsValueType属性来判断一个类型是否为值类型:

TestType testType = new TestType ();

if (testTypetype.GetType().IsValueType)

{

     Console.WriteLine("{0} is value type.", testType.ToString());

}

 

3.引用类型

C#有以下一些引用类型:

数组(派生于System.Array)

用户用定义的以下类型:

类:class(派生于System.Object);

接口:interface(接口不是一个“东西”,所以不存在派生于何处的问题。Anders在《C# Programming Language》中说,接口只是表示一种约定[contract]);

委托:delegate(派生于System.Delegate)。

object(System.Object的别名);

字符串:string(System.String的别名)。

可以看出:

引用类型与值类型相同的是,结构体也可以实现接口;

引用类型可以派生出新的类型,而值类型不能;

引用类型可以包含null值,值类型不能(可空类型功能允许将 null 赋给值类型);

引用类型变量的赋值只复制对对象的引用,而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时,将复制包含的值。

对于最后一条,经常混淆的是string。我曾经在一本书的一个早期版本上看到String变量比string变量效率高;我还经常听说String是引用类型,string是值类型,等等。例如:

string s1 = "Hello, ";

string s2 = "world!";

string s3 = s1 + s2;//s3 is "Hello, world!"

 

这确实看起来像一个值类型的赋值。再如:

string s1 = "a";

string s2 = s1;

s1 = "b";//s2 is still "a"

 

改变s1的值对s2没有影响。这更使string看起来像值类型。实际上,这是运算符重载的结果,当s1被改变时,.NET在托管堆上为s1重新分配了内存。这样的目的,是为了将做为引用类型的string实现为通常语义下的字符串。

 

4. 值类型和引用类型在内存中的部署

经常听说,并且经常在书上看到:值类型部署在栈上,引用类型部署在托管堆上。实际上并没有这么简单。

MSDN上说:托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时:

object reference = new object();

 

关键字new将在托管堆上分配内存空间,并返回一个该内存空间的地址。左边的reference位于栈上,是一个引用,存储着一个内存地址;而这个地址指向的内存(位于托管堆)里存储着其内容(一个System.Object的实例)。下面为了方便,简称引用类型部署在托管推上。

再来看值类型。《C#语言规范》上的措辞是“结构体不要求在堆上分配内存(However, unlike classes, structs are value types and do not require heap allocation)”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑:值类型究竟部署在什么地方?

4.1数组

考虑数组:

int[] reference = new int[100];

根据定义,数组都是引用类型,所以int数组当然是引用类型(即reference.GetType().IsValueType为false)。

而int数组的元素都是int,根据定义,int是值类型(即reference[i].GetType().IsValueType为true)。那么引用类型数组中的值类型元素究竟位于栈还是堆?

如果用WinDbg去看reference[i]在内存中的具体位置,就会发现它们并不在栈上,而是在托管堆上。

实际上,对于数组:

TestType[] testTypes = new TestType[100];

如果TestType是值类型,则会一次在托管堆上为100个值类型的元素分配存储空间,并自动初始化这100个元素,将这100个元素存储到这块内存里。

如果TestType是引用类型,则会先在托管堆为testTypes分配一次空间,并且这时不会自动初始化任何元素(即testTypes[i]均为null)。等到以后有代码初始化某个元素的时候,这个引用类型元素的存储空间才会被分配在托管堆上。

 

4.2类型嵌套

 c#中的值类型和引用类型 装箱拆箱 (好文)

引用类型部署在托管堆上;

值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实例)存储;作为局部变量时,存储在栈上。

从上下文看,mc是一个局部变量,所以部署在托管堆上,并被栈上的一个引用所持有;

值类型字段_value1属于引用类型实例mc的一部分,所以跟随引用类型实例mc部署在托管堆上(有点类似于数组的情形);

value2是值类型局部变量,所以部署在栈上。

而对于值类型实例,即MyStruct

根据上下文,值类型实例ms本身是一个局部变量而不是字段,所以位于栈上;

其引用类型字段_object1不存在跟随的问题,必然部署在托管堆上,并被一个引用所持有(该引用是ms的一部分,位于栈);

其引用类型局部变量_object2显然部署在托管堆上,并被一个位于栈的引用所持有。

所以,简单地说“值类型存储在栈上,引用类型存储在托管堆上”是不对的。必须具体情况具体分析

 

 

C#中,我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子:

SomeType[] oneTypes = new SomeType[100];

如 果SomeType是值类型,则只需要一次分配,大小为SomeType的100倍。而如果SomeType是引用类型,刚开始需要100次分配,分配后 数组的各元素值为null,然后再初始化100个元素,结果总共需要进行101次分配。这将消耗更多的时间,造成更多的内存碎片。所以,如果类型的职责主 要是存储数据,值类型比较合适。

一般来说,值类型(不支持多态)适合存储供 C#应用程序操作的数据,而引用类型(支持多态)应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况,那么我们就应该创建为值类型:

该类型的主要职责用于数据存储。

该类型的共有接口完全由一些数据成员存取属性定义。

该类型永远不可能有子类。

该类型不具有多态行为。

 

5. 辨明值类型和引用类型的使用场合

在C#中,我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子:

SomeType[] oneTypes = new SomeType[100];

如 果SomeType是值类型,则只需要一次分配,大小为SomeType的100倍。而如果SomeType是引用类型,刚开始需要100次分配,分配后 数组的各元素值为null,然后再初始化100个元素,结果总共需要进行101次分配。这将消耗更多的时间,造成更多的内存碎片。所以,如果类型的职责主 要是存储数据,值类型比较合适。

一般来说,值类型(不支持多态)适合存储供 C#应用程序操作的数据,而引用类型(支持多态)应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况,那么我们就应该创建为值类型:

该类型的主要职责用于数据存储。

该类型的共有接口完全由一些数据成员存取属性定义。

该类型永远不可能有子类。

该类型不具有多态行为。

 

 

值类型和引用类型的区别(小结)

相同点:

引用类型可以实现接口,值类型当中的结构体也可以实现接口;

引用类型和值类型都继承自System.Object类。

 

1)范围方面

C#的值类型包括:结构体(数值类型、bool型、用户定义的结构体),枚举,可空类型。

C#的引用类型包括:数组,用户定义的类、接口、委托,object,字符串。

2)内存分配方面:

数组的元素不管是引用类型还是值类型,都存储在托管堆上。

引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。简称引用类型部署在托管推上。而值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实 例)存储;作为局部变量时,存储在栈上。(栈的内存是自动释放的,堆内存是.NET中会由GC来自动释放)

3)适用场合

值类型在内存管理方面具有更好的效率,并且不支持多态,适合用做存储数据的载体;引用类型支持多态,适合用于定义应用程序的行为。

引用类型可以派生出新的类型,而值类型不能,因为所有的值类型都是密封(seal)的;

引用类型可以包含null值,值类型不能(可空类型功能允许将 null 赋给值类型,如   int? a = null;  );

引用类型变量的赋值只复制对对象的引用,而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时,将复制包含的值。

 

值得注意的是,引用类型和值类型都继承自System.Object类。不同的是,几乎所有的引用类型都直接从System.Object继承,而值类型则继承其子类,即 直接继承System.ValueType。即System.ValueType本身是一个类类型,而不是值类型。其关键在于ValueType重写了Equals()方法,从而对值类型按照实例的值来比较,而不是引用地址来比较。

内容参考来自文章:

值类型和引用类型,栈和堆的含义

通用类型系统概述

C#详解值类型和引用类型区别