CLR via C# on 冯威的博客

CLR Via C# 学习笔记（6）方法参数相关（out ref params）

Thu, 16 Jul 2009 00:00:00 +0800

CLR Via C#》这本书以前就粗略看过两遍，但一直都没能深入理解，而且很多内容也忘记了，现在准备重新看一遍，并将看过的部分写出来，因为写的过程也是一个加深理解的过程。本系列算是学习的一个记录吧，也可以方便以后自己查阅，如果对大家还有些帮助的话，我就很高兴了。书我是选择性的看的，所以顺序和书中的顺序可能不一样。

通常我们在使用方法的时候，方法的参数是按值传递的，如果传递的参数是引用类型的对象，是将引用对象的地址传给方法。如果传递的是值类型实例，传递给方法的是该实例的一个副本。允许使用在方法中按引用来传递参数，C#中使用out和ref关键字来体现。下面就来介绍out和ref的使用。

out

1 使用out时在方法的参数定义和方法的调用时都要用out关键字，如下：

static void Main(string[] args)
{
 string name = string.Empty;
 GetStr(out name); //调用时加out
 Console.WriteLine(name);
}
private static void GetStr(out string name) //方法参数定义时的out
{
 name = "oec2003";
}

2 如果一个方法有out修饰的参数，在方法结束前必须给给参数赋值，否则不能通过编译，代码如下：

static void Main(string[] args)
{
 string name = "oec2003";
 GetStr(out name);
 Console.WriteLine(name);
}
private static void GetStr(out string name)
{
 //没有给name赋值，编译时会出现“控制离开当前方法之前必须对
 //out 参数“name”赋值”异常
}

3 在调用有out参数的方法时，没有必要给out参数赋初始值，因为赋的值不会传递到方法的内部，如果在方法的内部要强行使用out参数会有编译错误。代码如下：

static void Main(string[] args)
{
 //给out参数name赋初始值oec2003
 string name = "oec2003";
 GetStr(out name);
 Console.WriteLine(name);
}
private static void GetStr(out string name)
{
 name = "hello" + name;
 //name在调用前虽赋值为oec2003 ，
 //但此处会报错“使用了未赋值的 out 参数name”
}

4 通常我们需要在一个方法中返回多个值的时候就可以使用out参数。

5 如果两个方法的参数个数和类型都相同，区别只是其中一个为out参数，那么这两个方法是可以进行重载的，下面的代码可以正常运行。

private static void GetStr(out string name)
{
 name = "oec2003";
}
private static void GetStr(string name)
{
 name = "oec2003";
}

ref

1 和out参数一样，使用ref时在方法的参数定义和方法的调用时都要用ref关键字。

CLR Via C# 学习笔记（5）静态构造函数的性能

Wed, 08 Jul 2009 00:00:00 +0800

CLR Via C#》这本书以前就粗略看过两遍，但一直都没能深入理解，而且很多内容也忘记了，现在准备重新看一遍，并将看过的部分写出来，因为写的过程也是一个加深理解的过程。本系列算是学习的一个记录吧，也可以方便以后自己查阅，如果对大家还有些帮助的话，我就很高兴了。书我是选择性的看的，所以顺序和书中的顺序可能不一样。

在上一篇《CLR Via C# 学习笔记（4）方法构造函数》中讲到了一些静态构造函数方面的知识，现在也回顾一下，大概总结如下：

静态构造函数是私有的（private），而且不能人为去修改访问修饰符。
静态构造函数不应该去调用基类的静态构造函数，因为静态字段不会被继承到子类。
静态构造函数在一个类型中有且仅有一个，并且是无参的。
静态构造函数中只能初始化静态字段。

从上面的第一点可以知道静态构造函数都是private的，所以不能显示区进行调用，关于JIT何时会去生成调用静态构造函数的代码。存在着两种说法。通常被称为Precise和BeforeFieldInit。

Precise方式JIT编译器生成调用的时机：首次创建类型的代码之前；访问类的非继承字段或成员代码之前。
BeforeFieldInit方式JIT编译器生成调用的时机：在访问费继承静态字段代码之前。

这两种方式的主要区别就是选择调用静态构造函数的时机是否是确定的，Precise方式CLR会在确定的时刻调用静态构造函数，而BeforeFieldInit方式CLR可以自由选择调用静态构造函数的时机，利用这一点，CLR可以根据类型是否在程序域中加载来选择静态构造函数的调用次数，以便能生成执行更快的代码。

下面来看来个类分别展现了这两种方式

public classUserPrecise
{
 public static string_name = "内联赋值：oec2003";
 staticUserPrecise()
 {
 _name = "构造函数赋值：oec2003";
 }
}
public classUserBeforeFieldInit
{
 public static string_name = "内联赋值：oec2003";
}

通过IL代码可以看出在UserBeforeFieldInit 的元数据上有BeforeFieldInit的标记，如下图：

既然上面提到BeforeFieldInit方式CLR可以选择调用构造函数的次数从而来生成执行更快的代码，下面就写一段测试代码来看看究竟怎样。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


public sealed class Program
{
 static void Main(string[] args)
 {
 const Int32 iterations = 1000 * 1000 * 1000;
 Test1(iterations);
 Test2(iterations);
 }

 private static void Test1(Int32 iterations)
 {
 Stopwatch sw = Stopwatch.StartNew();
 for (Int32 i = 0; i < iterations; i++)
 {
 UserBeforeFieldInit._name = "oec2003";
 }
 Console.WriteLine("Test1-UserBeforeFieldInit 用时：" + sw.Elapsed);

 sw = Stopwatch.StartNew();
 for (Int32 j = 0; j < iterations; j++)
 {
 UserPrecise._name = "oec2003";
 }
 Console.WriteLine("Test1-UserPrecise 用时：" + sw.Elapsed);
 }

 private static void Test2(Int32 iterations)
 {
 Stopwatch sw = Stopwatch.StartNew();
 for (Int32 i = 0; i < iterations; i++)
 {
 UserBeforeFieldInit._name = "oec2003";
 }
 Console.WriteLine("Test2-UserBeforeFieldInit 用时：" + sw.Elapsed);

 sw = Stopwatch.StartNew();
 for (Int32 j = 0; j < iterations; j++)
 {
 UserPrecise._name = "oec2003";
 }
 Console.WriteLine("Test2-UserPrecise 用时：" + sw.Elapsed);
 }
}

public class UserBeforeFieldInit
{
 public static string _name;
}

public class UserPrecise
{
 public static string _name;

 static UserPrecise()
 {
 _name = "oec2003";
 }
}

测试结果如下：

CLR Via C# 学习笔记（4）方法构造函数

Fri, 03 Jul 2009 00:00:00 +0800

《CLR Via C#》这本书以前就粗略看过两遍，但一直都没能深入理解，而且很多内容也忘记了，现在准备重新看一遍，并将看过的部分写出来，因为写的过程也是一个加深理解的过程。本系列算是学习的一个记录吧，也可以方便以后自己查阅，如果对大家还有些帮助的话，我就很高兴了。书我是选择性的看的，所以顺序和书中的顺序可能不一样。

构造函数是可以将类型实例初始化为有效状态的特殊方法。构造函数在元数据中通常用.ctor来表示，通过IL代码可以看到。在创建一个类型的实例时，通常分为三步：

为实例的数据字段分配内存。
创建对象指针和同步索引块。
调用类型的实例构造器来设置对象的初始状态。

引用类型的实例构造器

在创建一个引用类型的对象是，调用类型的实例构造函数之前，会将对象分配的内存做清零处理，就是说在构造函数中没有显示赋值的所有字段都将设置为0或null。

实例构造函数和一般方法不同，他永远都不能被继承，所有以下的关键字也不能用于实例构造函数（virtual new override sealed abstract）。

一个类中如果没有显示定义任何构造函数，C#编译器将定义一个默认的无参构造函数。

抽象（abstract）类的默认构造函数的访问修饰符为protected。

构造函数可以初始化字段，不过在c#语言中提供了一种简单的方法，在定义字段的时候直接赋值以初始化。如下：

public class User
{
 private int _age = 25;
 private string _name = "oec2003";
}

像上面那样的确很方便，但如果有好几个已经初始化的实例字段和多个重载的构造函数同时存在的情况下，就应该将实例字段的初始化放到一个公共的构造函数中，其他的构造函数通过this来显示调用该构造函数，这样可以减少代码生成的大小，看下面的例子。

public abstract class User
{
 private int _age = 25;
 private string _name = "oec2003";
 private string _email = "oec2003@gmail.com";

 public User(Int32 age)
 {
 this._age = age;
 }

 public User(string name)
 {
 this._name = name;
 }

 public User(Int32 age, String name, String email)
 {
 this._age = age;
 this._name = name;
 this._email = email;
 }
}

正确的写法应该像下面这样

public abstract class User
{
 private int _age;
 private string _name;
 private string _email;

 public User()
 {
 _age = 25;
 _name = "oec2003";
 _email = "oec2003@gmail.com";
 }

 public User(Int32 age)
 : this()
 {
 this._age = age;
 }

 public User(string name)
 : this()
 {
 this._name = name;
 }

 public User(Int32 age, String name, String email)
 : this()
 {
 this._age = age;
 this._name = name;
 this._email = email;
 }
}

值类型的实例构造函数

值类型的实例构造函数和引用类型的有很大不同，在值类型中不能含有无参的构造函数，如果显式指定无参的构造函数将会出现编译错误。如下面代码会出现编译错误：

CLR Via C# 学习笔记（3）常量和字段（const readonly）

Mon, 22 Jun 2009 00:00:00 +0800

《CLR Via C#》这本书以前就粗略看过两遍，但一直都没能深入理解，而且很多内容也忘记了，现在准备重新看一遍，并将看过的部分写出来，因为写的过程也是一个加深理解的过程。本系列算是学习的一个记录吧，也可以方便以后自己查阅，如果对大家还有些帮助的话，我就很高兴了。书我是选择性的看的，所以顺序和书中的顺序可能不一样。

常量和字段都是类型的数据成员，但是区别却是很大的。

常量的值永远不会改变。字段有多种类型，非只读字段的值是可以改变的。
常量的值必须在编译时就确定，也就是说在定义时就要赋值。编译后常量的值就保存在程序集的元数据中；字段是存储在动态内存中，在运行时才能得到字段的值。
常量的定义必须用基元类型，关于基元类型可以参考(CLR Via C# 学习笔记（1）基元类型值类型引用类型 )；字段的定义可以是任何类型。
因为常量的值不能改变，可以将其看做是静态类型，在IL代码中可以看到常量有static修饰符，所以在调用的时候和调用静态字段一样，直接用类名.常量名；字段中的静态字段的调用才和常量一样直接用类名.字段名，调用非静态字段必须用类的实例。、
C#不允许使用static修饰常量，因为常量本身就隐含是static类型；字段可以使用static，使用static定义的字段为静态字段。

下面看个例子来理解下常量

1 创建一个类库项目命名为Oec2003ClassLibrary ,在默认的类Class1中写如下代码

namespace Oec2003ClassLibrary
{
 public class Class1
 {
 public const double PI = 3.14;

 public static double _pi = 3.14;
 }
}

2 创建一个web项目，添加对Oec2003ClassLibrary类库项目的引用，新建页面ConstTest.aspx,在PageLoad中写如下代码

protected void Page_Load(object sender, EventArgs e)
{
 Response.Write(Class1.PI+"<br/>");
 Response.Write(Class1._pi);
}

3 将ConstTest设为起始页，运行，可以看到结果如下

4 现在将Oec2003ClassLibrary 项目中的Class1的代码改写如下，然后从新编译该项目。

namespace Oec2003ClassLibrary
{
 public class Class1
 {
 public const double PI = 3.1415926;
 public static double _pi = 3.1415926;
 }
}

5 刷新刚才的页面，可以看到结果如下

6 从新运行ConstTest页面可以看到如下结果

从上面的例子可以看出，在应用程序不从新编译的情况下，常量的值永远不会发生改变。如果应用程序想要获得常量的新值，就必须重新编译，所以在运行时一个应用程序集想获得另一个应用程序集中的值，则不能使用常量，可以使用只读字段（readonly）。

字段也是一种类型的数据成员，字段的修饰符有 static readonly volatile，没有上述修饰修饰的字段为普通的实例字段。static可以和readonly一起使用，就是静态只读字段。有关volatile将在后面的部分介绍。

关于readonly要注意的地方

当readonly修饰的字段为值类型时，在调用的时候如果视图去改变字段的值，将会编译出错。
当readonly修饰的字段为引用类型时，调用时不能改变其引用，但可以改变应用对象的值，看下面的例子。

1 在Oec2003ClassLibrary项目的Class1.cs文件写如下代码

namespace Oec2003ClassLibrary
{
 public class Class1
 {
 public const double PI = 3.14;
 public static readonly double _pi = 3.14;

 public static readonly User user = new User("oec2003");
 }
 public class User
 {
 public User(string name)
 {
 Name = name;
 }
 public string Name { get; set; }
 }
}

2 在web项目中添加页面，命名为Readonly.aspx，PageLoad代码如下

CLR Via C# 学习笔记（2）装箱和拆箱

Thu, 18 Jun 2009 00:00:00 +0800

CLR Via C#》这本书以前就粗略看过两遍，但一直都没能深入理解，而且很多内容也忘记了，现在准备重新看一遍，并将看过的部分写出来，因为写的过程也是一个加深理解的过程。本系列算是学习的一个记录吧，也可以方便以后自己查阅，如果对大家还有些帮助的话，我就很高兴了。书我是选择性的看的，所以顺序和书中的顺序可能不一样。

装箱和拆箱是已经被嚼烂的两个概念了，并且在一些面试中也经常考到。

装箱：将值类型转换为引用类型。
拆箱：将引用类型转换为值类型。

值类型是一种相对轻型的类型，不像对象那样在托管堆中分配，也不会被GC，不通过指针来引用，不过在有些时候需要获取对值类型的引用，例如在使用net1.0的集合类ArrayList的时候。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Program
{
 static void Main(string[] args)
 {
 ArrayList list = new ArrayList();
 Point p; //因Point为值类型，分配在堆栈中
 for (int i = 0; i < 100; i++)
 {
 p.x = p.y = i; //初始化Point中的成员
 list.Add(p); //对p进行装箱后，将引用添加到list中
 }
 }
}
struct Point
{
 public Int32 x;
 public Int32 y;
}

ArrayList的Add方法是接受一个Object参数，如下

1

public virtual int Add(object value);

所以在执行Add方法时会将Point值类型转换为一个堆得托管对象，并获取到这个对象的引用，将引用地址存储在ArrayList中。

在一个值类型装箱的时候内部发生的事情：

在托管堆分配好内存。分配的内存是值类型的各个字段所需内存量加上托管堆上的两个额外成员（类型对象指针和同步索引块）所需的内存量。
值类型中的字段值复制到新分配的堆内存中。
返回对象的引用地址。

拆箱就是执行和装箱相反的操作，将引用类型转化为值类型。接上面的代码，获取ArrayList中的元素值用如下代码：

1
2
3
4
5


for (int j = 0; j < 10; j++)
{
 Point point =(Point)list[j];
 Console.WriteLine("X:" + point.x + " Y:" + point.y);
}

上面的代码中通过索引取到ArrayList中存储的各个Point的引用地址，通过Point类型转换将其对应的值从堆中复制到Point的实例point中，这个转换的过程就是拆箱的过程。

在拆箱的过程中要注意以下两点：

如果对已装箱的值类型的引用的变量为null，会引发NullRefreenceException异常
如果一个引用指向的对象在拆箱时不是用的装箱时所使用的类型，将会引发InvalidCastException异常。代码如下：

1
2
3
4
5
6


static void Main(string[] args)
{
 Int32 x = 5;
 Object o = x;
 Int16 y = (Int16)o; //引发InvalidCastException异常
}

正确的做法是，现将其用Int32类型来拆箱，然后再强制转换为Int16

1
2
3
4
5
6


static void Main(string[] args)
{
 Int32 x = 5;
 Object o = x;
 Int16 y = (Int16)(Int32)o;
}

下面来看两段程序来深入理解下装箱和拆箱

代码一：

1
2
3
4
5
6
7
8


static void Main(string[] args)
{
 Int32 x = 5;
 Object o = x;
 x = 123;

 Console.WriteLine(x + ", " + (Int32)o);
}

上面的代码中有多少次装箱呢？乍一看好像就一次（Object o=x；），其实一共有三次装箱，看看IL代码就一目了然了。

CLR Via C# 学习笔记（1）基元类型值类型引用类型

Wed, 17 Jun 2009 00:00:00 +0800

CLR Via C#》这本书以前就粗略看过两遍，但一直都没能深入理解，而且很多内容也忘记了，现在准备重新看一遍，并将看过的部分写出来，因为写的过程也是一个加深理解的过程。本系列算是学习的一个记录吧，也可以方便以后自己查阅，如果对大家还有些帮助的话，我就很高兴了。书我是选择性的看的，所以顺序和书中的顺序可能不一样。

首先了解下什么是基元类型，基元类型是编译器直接支持的数据类型，像我们平时经常用到的int string bool 都是基元类型，基元类型是映射到FCL中的类型，像前面的三种类型对应到FCL中就是Int32 String Boolean，基元类型只是给我们的编程提供了方便，它和FCL中的类型在编译后最终生成的IL完全相同。下面给出基元类型和FCL类型的对应表

C#基元类型	FCL类型	CLS相容	说明
sbyte	System.Sbyte
byte	System.Byte
short	System.Int16
ushort	System.UInt16
int	System.Int32
uint	System.Uint32
long	System.Int64
ulong	System.Uint64
char	System.Char
float	System.Single
double	System.Double
bool	System.Boolean
decimal	System.Decimal
object	System.Object
string	System.String

我们平时在写程序时通常都是使用基元类型，因为方便，但本书的作者认为应该直接使用FCL中的类型，原因如下：

在c#中long对应的FCL类型为System.Int64，但是在其他的语言中，如c++ 就将long视为一个Int32。这样习惯于一种编程语言的人在看另一种编程语言写的源码是就会产生错误的理解。
在FCL中的许多的方法将类型名作为方法名的一部分，如System.Convert类提供ToBoolean,ToInt32,ToSingle等。这样在使用基元类型做类型转换时就感觉有点怪怪的，如：float val=Convert.ToSingle(“23”);

值类型和引用类型的区别

所有的值类型都是从System.TypeValue派生，如Struct Enum都是值类型；所有引用类型都是从System.Object派生。
值类型分配在线程堆栈上，引用类型分配在托管堆上。
值类型表现形式有未装箱形式和已装箱形式，而引用类型总是已装箱形式。
所有的值类型都是sealed类型，所以值类型不能作为任何类型的基类型，也不能在值类型中引入虚方法。
创建一个引用类型变量时，会被初始化为null，试图使用一个null的引用类型变量时，会抛出NullReferenceException异常，也就是常见的“未将对象引用设置到对象的实例”；值类型在创建时所有成员都初始化为0了，所以不会抛出该异常。

原文例子表示值类型和引用类型的区别

class Program
{
 static void Main(string[] args)
 {
 SomeRef r1 = new SomeRef();
 SomeVal v1 = new SomeVal();
 r1.x = 5;
 v1.x = 5;
 Console.WriteLine(r1.x); //5
 Console.WriteLine(v1.x); //5
 SomeRef r2 = r1;
 SomeVal v2 = v1;
 r1.x = 8;
 v1.x = 9;
 Console.WriteLine(r1.x); //8
 Console.WriteLine(r2.x); //9
 Console.WriteLine(v1.x); //9
 Console.WriteLine(v2.x); //5
 }
}
class SomeRef
{
 public Int32 x;
}
struct SomeVal
{
 public Int32 x;
}

CLR中类型字段布局的控制

为了提高性能，clr能按照所选择的任何方式来排列类型的字段。我们可以通过在类会是结构上使用System.Runtime.InteropServices.StructLayoutAttribute属性来改变这种排列的顺序。该属性接受一个LayoutKind的枚举值（Auto，Sequential，Explicit），默认情况下C#编译器会为类选择Atuo，为结构选择Sequential。下面来定义一个类和一个结构

CLR via C# on 冯威的博客

CLR Via C# 学习笔记（6） 方法参数相关（out ref params）

out

ref

CLR Via C# 学习笔记（5） 静态构造函数的性能

CLR Via C# 学习笔记（4） 方法 构造函数

引用类型的实例构造器

值类型的实例构造函数

CLR Via C# 学习笔记（3） 常量和字段（const readonly）

下面看个例子来理解下常量

关于readonly要注意的地方

CLR Via C# 学习笔记（2） 装箱和拆箱

CLR Via C# 学习笔记（1） 基元类型 值类型 引用类型

值类型和引用类型的区别

原文例子表示值类型和引用类型的区别

CLR中类型字段布局的控制

CLR Via C# 学习笔记（6）方法参数相关（out ref params）

CLR Via C# 学习笔记（5）静态构造函数的性能

CLR Via C# 学习笔记（4）方法构造函数

CLR Via C# 学习笔记（3）常量和字段（const readonly）

CLR Via C# 学习笔记（2）装箱和拆箱

CLR Via C# 学习笔记（1）基元类型值类型引用类型