再议C#中的装箱与拆箱的问题详解
上一篇写了一下装箱拆箱的定义和IL分析，这一篇我们看下使用泛型和不使用泛型引发装箱拆箱的情况
1.使用非泛型集合时引发的装箱和拆箱操作
看下面的一段代码：
代码如下:
var array = new ArrayList();
array.Add(1);
array.Add(2);
foreach (int value in array)
{
Console.WriteLine(“value is {0}”,value);
}
代码声明了一个ArrayList对象，向ArrayList中添加两个数字1，2；然后使用foreach将ArrayList中的元素打印到控制台。
在这个过程中会发生两次装箱操作和两次拆箱操作，在向ArrayList中添加int类型元素时会发生装箱，在使用foreach枚举ArrayList中的int类型元素时会发生拆箱操作，将object类型转换成int类型，在执行到Console.WriteLine时，还会执行两次的装箱操作；这一段代码执行了6次的装箱和拆箱操作；如果ArrayList的元素个数很多，执行装箱拆箱的操作会更多。
你可以通过使用ILSpy之类的工具查看IL代码的box，unbox指令查看装箱和拆箱的过程
2.使用泛型集合的情况
请看如下代码：
代码如下:
var list = new List<int>();
list.Add(1);
list.Add(2);
foreach (int value in list)
{
Console.WriteLine("value is {0}", value);
}
代码和1中的代码的差别在于集合的类型使用了泛型的List，而非ArrayList；我们同样可以通过查看IL代码查看装箱拆箱的情况，上述代码只会在Console.WriteLine()方法时执行2次装箱操作，不需要拆箱操作。
可以看出泛型可以避免装箱拆箱带来的不必要的性能消耗；当然泛型的好处不止于此，泛型还可以增加程序的可读性，使程序更容易被复用等等。
本文使用的C#代码如下：
代码如下:
using System;
using System.Collections;
using System.Collections.Generic;
namespace boxOrUnbox
{
class Program
{
static void Main(string[] args)
{
//do nothing
}
static void Box()
{
object objValue = 9;
}
static void Unbox()
{
object objValue = 4;
int value = (int)objValue;
}
static void LookatArrayList()
{
var array = new ArrayList();
array.Add(1);
array.Add(2);
foreach (int value in array)
{
Console.WriteLine("value is {0}", value);
}
}
static void LookatGenericList()
{
var list = new List<int>();
list.Add(1);
list.Add(2);
foreach (int value in list)
{
Console.WriteLine("value is {0}", value);
}
}
}
}
.class private auto ansi beforefieldinit boxOrUnbox.Program
extends [mscorlib]System.Object
{
// Methods
.method private hidebysig static
void Main (
string[] args
) cil managed
{
// Method begins at RVA 0x2050
// Code size 2 (0x2)
.maxstack 8
.entrypoint
IL_0000: nop
IL_0001: ret
} // end of method Program::Main
.method private hidebysig static
void Box () cil managed
{
// Method begins at RVA 0x2054
// Code size 10 (0xa)
.maxstack 1
.locals init (
[0] object objValue
)
IL_0000: nop
IL_0001: ldc.i4.s 9
IL_0003: box [mscorlib]System.Int32
IL_0008: stloc.0
IL_0009: ret
} // end of method Program::Box
.method private hidebysig static
void Unbox () cil managed
{
// Method begins at RVA 0x206c
// Code size 16 (0x10)
.maxstack 1
.locals init (
[0] object objValue,
[1] int32 'value'
)
IL_0000: nop
IL_0001: ldc.i4.4
IL_0002: box [mscorlib]System.Int32
IL_0007: stloc.0
IL_0008: ldloc.0
IL_0009: unbox.any [mscorlib]System.Int32
IL_000e: stloc.1
IL_000f: ret
} // end of method Program::Unbox
.method private hidebysig static
void LookatArrayList () cil managed
{
// Method begins at RVA 0x2088
// Code size 114 (0x72)
.maxstack 2
.locals init (
[0] class [mscorlib]System.Collections.ArrayList 'array',
[1] int32 'value',
[2] class [mscorlib]System.Collections.IEnumerator CS$5$0000,
[3] bool CS$4$0001,
[4] class [mscorlib]System.IDisposable CS$0$0002
)
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor()
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: ldc.i4.1
IL_0009: box [mscorlib]System.Int32
IL_000e: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_0013: pop
IL_0014: ldloc.0
IL_0015: ldc.i4.2
IL_0016: box [mscorlib]System.Int32
IL_001b: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_0020: pop
IL_0021: nop
IL_0022: ldloc.0
IL_0023: callvirt instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Collections.ArrayList::GetEnumerator()
IL_0028: stloc.2
.try
{
IL_0029: br.s IL_004a
// loop start (head: IL_004a)
IL_002b: ldloc.2
IL_002c: callvirt instance object [mscorlib]System.Collections.IEnumerator::get_Current()
IL_0031: unbox.any [mscorlib]System.Int32
IL_0036: stloc.1
IL_0037: nop
IL_0038: ldstr "value is {0}"
IL_003d: ldloc.1
IL_003e: box [mscorlib]System.Int32
IL_0043: call void [mscorlib]System.Console::WriteLine(string, object)
IL_0048: nop
IL_0049: nop
IL_004a: ldloc.2
IL_004b: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
IL_0050: stloc.3
IL_0051: ldloc.3
IL_0052: brtrue.s IL_002b
// end loop
IL_0054: leave.s IL_0070
} // end .try
finally
{
IL_0056: ldloc.2
IL_0057: isinst [mscorlib]System.IDisposable
IL_005c: stloc.s CS$0$0002
IL_005e: ldloc.s CS$0$0002
IL_0060: ldnull
IL_0061: ceq
IL_0063: stloc.3
IL_0064: ldloc.3
IL_0065: brtrue.s IL_006f
IL_0067: ldloc.s CS$0$0002
IL_0069: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL_006e: nop
IL_006f: endfinally
} // end handler
IL_0070: nop
IL_0071: ret
} // end of method Program::LookatArrayList
.method private hidebysig static
void LookatGenericList () cil managed
{
// Method begins at RVA 0x2118
// Code size 90 (0x5a)
.maxstack 2
.locals init (
[0] class [mscorlib]System.Collections.Generic.List`1<int32> list,
[1] int32 'value',
[2] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> CS$5$0000,
[3] bool CS$4$0001
)
IL_0000: nop
IL_0001: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor()
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: ldc.i4.1
IL_0009: callvirt instance void class [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0)
IL_000e: nop
IL_000f: ldloc.0
IL_0010: ldc.i4.2
IL_0011: callvirt instance void class [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0)
IL_0016: nop
IL_0017: nop
IL_0018: ldloc.0
IL_0019: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> class [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator()
IL_001e: stloc.2
.try
{
IL_001f: br.s IL_003c
// loop start (head: IL_003c)
IL_0021: ldloca.s CS$5$0000
IL_0023: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
IL_0028: stloc.1
IL_0029: nop
IL_002a: ldstr "value is {0}"
IL_002f: ldloc.1
IL_0030: box [mscorlib]System.Int32
IL_0035: call void [mscorlib]System.Console::WriteLine(string, object)
IL_003a: nop
IL_003b: nop
IL_003c: ldloca.s CS$5$0000
IL_003e: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
IL_0043: stloc.3
IL_0044: ldloc.3
IL_0045: brtrue.s IL_0021
// end loop
IL_0047: leave.s IL_0058
} // end .try
finally
{
IL_0049: ldloca.s CS$5$0000
IL_004b: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>
IL_0051: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL_0056: nop
IL_0057: endfinally
} // end handler
IL_0058: nop
IL_0059: ret
} // end of method Program::LookatGenericList
.method public hidebysig specialname rtspecialname
instance void .ctor () cil managed
{
// Method begins at RVA 0x2190
// Code size 7 (0x7)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: ret
} // end of method Program::.ctor
} // end of class boxOrUnbox.Program
相关推荐
-
c#装箱和拆箱知识整理
1.装箱和拆箱是一个抽象的概念 2.装箱是将值类型转换为引用类型 : 拆箱是将引用类型转换为值类型 利用装箱和拆箱功能,可通过允许值类型的任何值与Object 类型的值相互转换,将值类型与引用类型链接起来 例如: 复制代码 代码如下: int val = 100; object obj = val; Console.WriteLine ("对象的值 = {0}", obj); 这是一个装箱的过程,是将值类型转换为引用类型的过程 复制代码 代码如下: int val = 100; obj
-
C#装箱和拆箱原理详解
.NET包含一个特殊的Object类,可以接受任意的数据类型的值,当所传递或所赋值的类型不是一个特定的数据类型时,object类就提供了一种传递参数和赋值的通用方法.赋给object的值必须作为引用类型,并存放砸托管堆中. 装箱: int age = 24; object refAge= age; 可以看的出,第一条语句创建一个变量age,并将值放在托管栈中: 第二条语句将age的值赋给引用类型.它将值24放在托管堆中. 这个值类型包装为引用类型的过程,称为装箱. 拆箱: 相反,将引用类型转换为
-
Java拆装箱深度剖析
先来看一段代码: public class Main{ public static void main(String[] args){ Integer num1 = 100; Integer num2 = 100; Integer num3 = 200; Integer num4 = 200; '''//输出结果''' System.out.println(num1==num2); System.out.println(num3==num4); } } 猜猜结果是什么? 很多人都会认为结果全为t
-
java自动装箱拆箱深入剖析
这个是jdk1.5以后才引入的新的内容,作为秉承发表是最好的记忆,毅然决定还是用一篇博客来代替我的记忆: java语言规范中说道:在许多情况下包装与解包装是由编译器自行完成的(在这种情况下包装成为装箱,解包装称为拆箱): 其实按照我自己的理解自动装箱就可以简单的理解为将基本数据类型封装为对象类型,来符合java的面向对象:例如用int来举例: 复制代码 代码如下: //声明一个Integer对象 Integer num = 10; //以上的声明就是用到了自动的装箱:解析为 Integer nu
-
浅谈Java自动装箱与拆箱及其陷阱
在本文中,笔者向大家介绍下Java中一个非常重要也非常有趣的特性,就是自动装箱与拆箱,并从源码中解读自动装箱与拆箱的原理,同时这种特性也留有一个陷阱.开发者如果不注意,就会很容易跌入这个陷阱. 自动装箱(Autoboxing) 定义 大家在平时编写Java程序时,都常常以以下方式来定义一个Integer对象: Integer i=100; 从上面的代码中,大家可以得知,i为一个Integer类型的引用,100为Java中的基础数据类型(primitive data type).而这种直接将一个基
-
Java中的装箱和拆箱深入理解
自动装箱和拆箱问题是Java中一个老生常谈的问题了,今天我们就来一些看一下装箱和拆箱中的若干问题.本文先讲述装箱和拆箱最基本的东西,再来看一下面试笔试中经常遇到的与装箱.拆箱相关的问题. 一.什么是装箱?什么是拆箱? 在前面的文章中提到,Java为每种基本数据类型都提供了对应的包装器类型,至于为什么会为每种基本数据类型提供包装器类型在此不进行阐述,有兴趣的朋友可以查阅相关资料.在Java SE5之前,如果要生成一个数值为10的Integer对象,必须这样进行: 复制代码 代码如下: Intege
-
C#实现装箱与拆箱操作简单实例
本文以一个简单实例讲述了C#装箱和拆箱操作的实现方法,简单来说装箱是将值类型转换为引用类型:拆箱是将引用类型转换为值类型,是涉及栈和堆的使用方面的东西,学过C#的人应该都知道,所以这里就不哆嗦了,本例代码也是面向C#新手的,非常简单. 具体实现代码如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace UnBoxing { class Program {
-
轻松学习C#的装箱与拆箱
首先看一看什么是装箱和拆箱? 简单的来说: 装箱就是值类型转换为引用类型: 拆箱就是引用类型转换为值类型. 值类型,包括原类型(Sbyte.Byte.Short.Ushort.Int.Uint.Long.Ulong.Char.Float.Double.Bool.Decimal).枚举 (enum) .结构 (struct). 引用类型包括类.数组.接口.委托.字符串等. 装箱:值类型到引用类型或到此值类型所实现的任何接口类型的
-
.NET 中的装箱与拆箱实现过程
先看下面的代码: 复制代码 代码如下: int tempi = 1; object o = tempi; double tempd = (double) o; 编译时可以通过,但运行时却报如下错误: System.InvalidCastException: 指定的转换无效. 这是因为,当对一个对象进行拆箱时,转型的结果必须是它原来未装箱的类型.此处必须先转换为int类型,才能再转换为double类型.其正确格式如下: 复制代码 代码如下: int tempi = 32; object o = t
-
解析C#中的装箱与拆箱的详解
装箱和拆箱是值类型和引用类型之间相互转换是要执行的操作. 1. 装箱在值类型向引用类型转换时发生2. 拆箱在引用类型向值类型转换时发生光上述两句话不难理解,但是往深处了解,就需要一些篇幅来解释了.我们先看装箱时都会发生什么事情,下面是一行最简单的装箱代码 复制代码 代码如下: object obj = 1; 这行语句将整型常量1赋给object类型的变量obj: 众所周知常量1是值类型,值类型是要放在栈上的,而object是引用类型,它需要放在堆上:要把值类型放在堆上就需要执行一次装箱操作.这行