c++每隔10年左右，编程人员就需要花费大量的时间和精力去学习新的编程技术。在80年代是Unix和C，90年代是Windows和C++，现在又轮到了微软的.NETFramework和C#。尽管需要学习新的技术，但由此带来的好处却远高于付出的劳动。幸运的是，使用C#和.NET进行的大多数工程的分析和设计与在C++和Windows中没有本质的变化。在本篇文章中，我将介绍如何实现由C++到C#的飞跃。

已经有许多文章介绍过C#对C++的改进，在这里我就不再重复这些问题了。在这里，我将重点讨论由C++转向C#时最大的变化：由不可管理的环境向可管理的环境的变化。此外，我还会提出一些C#编程人员容易犯的错误供大家参考，此外，还将说明一些C#语言的能够影响编程的新功能。

转向可管理的环境

C++的设计目标是低级的、与平台无关的面向对象编程语言，C#则是一种高级的面向组件的编程语言。向可管理环境的转变意味着你编程方式思考的重大转变，C#不再处理细微的控制，而是让架构帮助你处理这些重要的问题。例如，在C++中，我们就可以使用new在栈中、堆中、甚至是内存中的某一特定位置创建一个对象。

在.NET的可管理环境中，我们再不用进行那样细微的控制了。在选择了要创建的类型后，它的位置就是固定的了。简单类型（ints、double和long）的对象总是被创建在栈中（除非它们是被包含在其他的对象中），类总是被创建在堆中。我们无法控制对象是创建在堆中哪个位置的，也没有办法得到这个地址，不能将对象放置在内存中的某一特定位置。（当然也有突破这些限制的方法，但那是很另类的方法。）我们再也不能控制对象的生存周期，C#没有destructor。碎片收集程序会将对象所占用的内存进行回收，但这是非显性地进行的。

正是C#的这种结构反映了其基础架构，其中没有多重继承和模板，因为在一个可管理的碎片收集环境中，多重继承是很难高效地实现的。

C#中的简单类型仅仅是对通用语言运行库（CLR）中类型的简单映射，例如，C#中的int是对System.Int32的映射。C#中的数据类型不是由语言本身决定的，而是由CLR决定的。事实上，如果仍然想在C#中使用在VisualBasic中创建的对象，就必须使自己的编程习惯更符合CLR的规定。

另一方面，可管理的环境和CLR也给我们带来了好处。除了碎片收集和所有.NET语言中统一的数据类型外，它还提供给我们一个功能强大的面向组件的编程语言，无须对后期绑定提供特别的支持，类型发现和后期绑定都是被内置在语言中的。属性是C#语言中的第一类的成员，事件和代理也是。

可管理环境最主要的优点是.NETFramework。尽管在所有的.NET语文中都可以使用这种框架，但C#可以更好地使用.NET框架中丰富的类、接口和对象。

Traps

C#看起来与C++非常相似，这使得我们在由C++转向C#时比较轻松，但其中也有一些容易出错的地方。在C++中编写得非常漂亮的代码，在C#中会不能通过编译，甚至会出现意想不到的结果。C#与C++之间在语法上的变化并不大，编译器能够发现这二者之间大部分的差异，我在这里就不再多费笔墨了，在这里我介绍几个容易出问题的比较重要的变化：

引用类型和值类型

在C#中，值类型和引用类型数据是有区别的。简单类型（int、long、double等）和结构属于值类型数据，类和对象属于引用类型数据。除非是包含在引用类型的变量中，与在C++中一样，值类型变量的值存储在栈中。引用类型的变量也存储在栈中，但它的值是一个存储在堆中的对象的地址，这一点也与C++类似。值类型变量是将自己的值传递给方法，而引用类型变量则将自己的指针传递给方法。

结构

C#中的结构与C++中有非常明显的区别。在C++中，结构更象是类，除了缺省的继承外，其缺省的访问权限是public而不是private。在C#中，结构与类截然不同，它是用来封装轻型对象的，是值类型的数据类型，在传递时传送的是变量的值，而不是其地址。此外，它们也有一些不适用于类的限制，例如，它是不能继承的，也没有除System.ValueType之外的基本类。结构还不能定义一个缺省的constructor。

另一方面，由于结构比类的效率要高，因此它非常适合于创建轻型对象。因此，如果它的缺点对你的软件没有影响，使用结构比使用类效率要高得多，尤其是对于小对象而言。

所有的一切都是对象

在C#中，所有的东西都是由继承Object得到的，包括创建的类和int、structs等值类型的变量。Object类提供了一些有用的方法，例如ToString，使用ToString的一个例子是与System.Console.WriteLine一起使用，它可以接受一个字符串和许多对象。与使用printf语句不同，要使用WriteLine，需要提供代换变量。假设myEmployee是用户定义的Employee类的一个实例，myCounter是用户定义的Counter类的一个实例：

Console.WriteLine("Theemployee:{0},thecountervalue:{1}",
myEmployee,myCounter);


其中的WriteLine会调用每个对象的Object.ToString方法，替换作为参数返回的变量。如果Employee类不覆盖ToString，就会调用缺省的实现（由System.Object继承得到的），它将把类的名字作为一个字符串返回。Counter会覆盖ToString，返回一个整型的变量，因此，上面代码的输出为：

Theemployee:Employee,thecountervalue:12


如果向WriteLine传递一个整型变量会发生什么情况呢？由于不能对整型变量调用ToString，编译器将自动将整型变量封装在一个对象的实例中。当WriteLine调用ToString时，对象就会返回表示整型变量值的字符串。下面的代码就说明了这个问题：

类的使用

usingSystem;
//不覆盖ToString的类
publicclassEmployee
{
}
//覆盖了ToString的类
publicclassCounter
{
privateinttheVal;
publicCounter(inttheVal)
{
this.theVal=theVal;
}
publicoverridestringToString()
{
Console.WriteLine("CallingCounter.ToString()");
returntheVal.ToString();
}
}
publicclassTester
{
publicstaticvoidMain()
{
//创建类的实例
Testert=newTester();
//调用非静态成员
//(mustbethroughaninstance)
t.Run();
}
//演示调用ToString的非静态方法
publicvoidRun()
{
EmployeemyEmployee=newEmployee();
CountermyCounter=newCounter(12);
Console.WriteLine("Theemployee:{0},thecountervalue:{1}",
myEmployee,myCounter);
intmyInt=5;
Console.WriteLine("Herearetwointegers:{0}and{1}",17,myInt);
}
}


引用型参数和输出型参数

与C++中相同，C#中的方法也只能有一个返回值。在C++中，我们通过将指针或索引作为参数而克服了这个限制，被调用的方法改变其中的参数，调用方法就可以得到新的值了。

向方法中传递一个索引作为参数时，只能严格地按传递索引或指针所能够提供的方式访问原来的对象。对于值类型变量而言，就不能采用这种方法了。如果要通过引用型参数传递值型变量，就需要在其前面加上ref关健字。如下所示：

publicvoidGetStats(refintage,refintID,refintyearsServed)


需要注意的是，既需要在方法的定义中使用ref关健字，也需要在对方法的实际调用中使用ref关健字。

Fred.GetStats(refage,refID,refyearsServed);


现在，我们可以在调用方法中定义age、ID和yearsServed变量，并将它们传递给GetStats，得到改变后的值。

C#要求明确的赋值，也就是说，在调用GetStats方法之前，必须对age、ID和yearsServed这三个局部变量进行初始化，这一工作似乎有点多余，因为我们仅仅使用它们从GetStats中得到新的变量的值。为了解决这一问题，C#提供了out关健字，表示我们可以向方法中传递没有被初始化的变量，这些变量将通过引用变量的方式进行传递：

publicvoidGetStats(outintage,outintID,outintyearsServed)


当然了，调用方法也必须作出相应的变化：

Fred.GetStats(outage,outID,outyearsServed);


New的调用

在C++中，new关健字可以在堆上生成一个对象。在C#中却不是这样。对于引用类型变量而言，new关健字在堆上生成一个对象；对于结构等值类型变量而言，new关健字在栈中生成一个对象，并需要调用constructor。

事实上，我们可以不使用new关健字而在栈上生成一个结构类型的变量，但这时需要注意的是，New关健字能够初始化对象。如果不使用new，则在使用前必须手工地对结构中的所有成员进行初始化，否则在编译时会出错。

对象的初始化

usingSystem;//有二个成员变量和一个构造器的简单结构
publicstructPoint
{
publicPoint(intx,inty)
{
this.x=x;
this.y=y;
}

publicintx;
publicinty;
}

publicclassTester
{
publicstaticvoidMain()
{
Testert=newTester();
t.Run();
}

publicvoidRun()
{
Pointp1=newPoint(5,12);
SomeMethod(p1);//fine

Pointp2;//不调用new而直接创建

//编译器编译到这里时会出错，因为p2的成员变量没有被初始化
//SomeMethod(p2);

//手工对它们进行初始化
p2.x=1;
p2.y=2;

SomeMethod(p2);

}

//一个可以接受Point作为参数的方法
privatevoidSomeMethod(Pointp)
{
Console.WriteLine("Pointat{0}x{1}",
p.x,p.y);
}
}




属性

大多数的C++编程人员都希望使成员变量的属性为private，这种隐藏数据的想法促进了数据封装概念的出现，使我们能够在不改变用户依赖的接口的情况下而改变类的实现。通常情况下，我们只希望客户获取或设置这些成员变量的值。因此，C++编程人员开发出了用来存取private成员变量的存取器。

在C#中，属性是类的第一级成员。对于客户而言，属性看起来象一个成员变量。对于类的实现者而言，它看起来更象是方法。这种设计很巧妙，既可以实现数据的隐藏和封装，又可以使客户很方便地访问成员变量。

我们可以在Employee类中添加一个Age属性，使客户可以很方便地获取和设置员工年龄这个类的成员：

publicintAge
{
get
{
returnage;
}
set
{
age=value;
}
}


关健字value可以被属性隐性地使用。如果编写如下的代码：

Fred.Age=17;


编译器将会把值17传递给value。

通过只采用Get而不采用Set，我们可以为YearsServed创建一个只读的属性：

publicintYearsServed
{
get
{
returnyearsServed;
}
}Accessors的使用
privatevoidRun()
{
EmployeeFred=newEmployee(25,101,7);
Console.WriteLine("Fred'sage:{0}",
Fred.Age);
Fred.Age=55;
Console.WriteLine("Fred'sage:{0}",
Fred.Age);

Console.WriteLine("Fred'sservice:{0}",
Fred.YearsServed);
//Fred.YearsServed=12;//是不被允许的

}




我们可以通过属性获取Fred的年龄，也可以使用这一属性设置年龄。我们虽然可以访问YearsServed属性获得它的值，但不能设置值。如果没有注释掉最后一行的代码，在编译时就会出错。

如果以后决定从数据库中获取Employee的年龄，我们就只需要改变存取器的实现，而客户不会受到任何影响。

数组

C#提供了一个数组类，它比C/C++中传统的数组更智能化。例如，在C#中写数组时不会超出边界。此外，数组还有一个更智能的伙伴—ArrayList，可以动态地增长，管理对数组大小不断变化的需求。

C#中的数组有三种形式：一维数组、多维均匀数组（象C++中传统的数组那样）、非均匀数组（数组的数组）。我们可以通过下面的代码创建一维数组：

int[]myIntArray=newint[5];


另外，还可以以如下的方式对它进行初始化：

int[]myIntArray={2,4,6,8,10};


我们可以通过如下方式创建一个4×3的均匀数组：

int[,]myRectangularArray=newint[rows,columns];


我们可以按如下方式对该数组进行初始化：

int[,]myRectangularArray=
{
{0,1,2},{3,4,5},{6,7,8},{9,10,11}
};



由于非均匀数组是数组的数组，因此，我们只能创建一维非均匀数组：

int[][]myJaggedArray=newint[4][];


然后再创建内部的每个数组：

myJaggedArray[0]=newint[5];
myJaggedArray[1]=newint[2];
myJaggedArray[2]=newint[3];
myJaggedArray[3]=newint[5];


由于数组是由继承System.Array对象而得到的，因此，它们带有许多包括Sort、Reverse在内的许多有用的方法。

索引器

我们可以创建象数组一样的对象。例如，我们可以创建一个显示一系列字符串的列表框，可以把列表框当作一个数组，使用一个索引就可以很方便地访问列表框中的内容。

stringtheFirstString=myListBox[0];
stringtheLastString=myListBox[Length-1];


这是通过索引器完成的。索引器在很大程度上象一个属性，但支持索引操作的语法。图4显示了一个后面跟着索引操作符的属性，图5显示如何完成一个很简单的ListBox类并对它进行索引：

界面

软件界面是二种对象之间如何进行交互的契约。如果一个对象发布了一个界面，就等于向所有可能的客户声明：我支持下面的方法、属性、事件和索引器。

C#是一种面向对象的语言，因此这些契约被封装在一个被称作界面的实体中，界面定义了封装着契约的引用型类型的对象。从概念上来讲，界面与抽象类非常相似，二者的区别是抽象类可以作为一系列衍生类的基础类，界面则是与其他继承树结合在一起的。

IEnumerable界面

再回到上面的例子中。象在普通的数组中那样，使用foreach-loop循环结构就能够很好地打印ListBoxTest类中的字符串，通过在类中实现IEnumerable界面就能实现，这是由foreach-loop循环结构隐性地完成的。在任何支持枚举和foreach-loop循环的类中都可以实现IEnumerable界面。

IEnumerable界面只有一个方法GetEnumerator，其任务是返回一个特别的IEnumerator的实现。从语法的角度来看，Enumerable类能够提供一个IEnumerator。

Figure5ListBoxClass
usingSystem;
//简化的ListBox控制
publicclassListBoxTest
{
//用字符串初始化该ListBox
publicListBoxTest(paramsstring[]initialStrings)
{
//为字符串分配空间
myStrings=newString[256];
//把字符串拷贝到构造器中
foreach(stringsininitialStrings)
{
myStrings[myCtr++]=s;
}
}
//在ListBox的末尾添加一个字符串
publicvoidAdd(stringtheString)
{
myStrings[myCtr++]=theString;
}
publicstringthis[intindex]
{
get
{
if(index<0||index>=myStrings.Length)
{
//处理有问题的索引
}
returnmyStrings[index];
}
set
{
myStrings[index]=value;
}
}
//返回有多少个字符串
publicintGetNumEntries()
{
returnmyCtr;
}
privatestring[]myStrings;
privateintmyCtr=0;
}
publicclassTester
{
staticvoidMain()
{
//创建一个新的列表并初始化
ListBoxTestlbt=newListBoxTest("Hello","World");
//添加一些新字符串
lbt.Add("Who");
lbt.Add("Is");
lbt.Add("John");
lbt.Add("Galt");
stringsubst="Universe";
lbt[1]=subst;
//访问所有的字符串
for(inti=0;i{
Console.WriteLine("lbt[{0}]:{1}",i,lbt[i]);
}
}
}


Enumerator必须实现IEnumerator方法，这可以直接通过一个容器类或一个独立的类实现，后一种方法经常被选用，因为它可以将这一任务封装在Enumerator类中，而不会使容器类显得很混乱。我们将在上面代码中的ListBoxTest中添加Enumerator类，由于Enumerator类是针对我们的容器类的（因为ListBoxEnumerator必须清楚ListBoxTest的许多情况），我们将使它在ListBoxTest中成为不公开的。在本例中，ListBoxTest被定义来完成IEnumerable界面，IEnumerable界面必须返回一个Enumerator。

publicIEnumeratorGetEnumerator()
{
return(IEnumerator)newListBoxEnumerator(this);
}


注意，方法将当前的ListBoxTest对象（this）传递给Enumerator，这将使Enumerator枚举这一指定的ListBoxTest对象中的元素。

实现这一类的Enumerator在这里被实现为ListBoxEnumerator，它在ListBoxTest中被定义成一个私有类，这一工作是相当简单的。

被枚举的ListBoxTest作为一个参数被传递给constructor，ListBoxTest被赋给变量myLBT，构造器还会将成员变量index设置为-1，表明对象的枚举还没有开始。

publicListBoxEnumerator(ListBoxTesttheLB)
{
myLBT=theLB;
index=-1;
}


MoveNext方法对index进行加1的操作，然后确保没有超过枚举的对象的边界。如果超过边界了，就会返回false值，否则返回true值。

publicboolMoveNext()
{
index++;
if(index>=myLBT.myStrings.Length)
returnfalse;
else
returntrue;
}


Reset的作用仅仅是将index的值设置为-1。

Current返回最近添加的字符串，这是一个任意的设定，在其他类中，Current可以有设计人员确定的意义。无论是如何设计的，每个进行枚举的方法必须能够返回当前的成员。

publicobjectCurrent
{
get
{
return(myLBT[index]);
}
}


对foreach循环结构的调用能够获取枚举的方法，并用它处理数组中的每个成员。由于foreach循环结构将显示每一个字符串，而无论我们是否添加了一个有意义的值，我们将myStrings的初始化改为8个条目，以保证显示的易于处理。

myStrings=newString[8];


使用基本类库

为了更好地理解C#与C++的区别和解决问题方式的变化，我们先来看一个比较简单的例子。我们将创建一个读取文本文件的类，并在屏幕上显示其内容。我将把它做成多线程程序，以便在从磁盘上读取数据时还可以做其他的工作。

在C++中，我们可能会创建一个读文件的线程和另一个做其他工作的线程，这二个线程将各自独立地运行，但可能会需要对它们进行同步。在C#中，我们也可以完成同样的工作，由于.NET框架提供了功能强大的异步I/O机制，在编写线程时，我们会节省不少的时间。

异步I/O支持是内置在CLR中的，而且几乎与使用正常的I/O流类一样简单。在程序的开始，我们首先通知编译器，我们将在程序中使用许多名字空间中的对象：

usingSystem;
usingSystem.IO;
usingSystem.Text;


在程序中包含System，并不会自动地包含其所有的子名字空间，必须使用using关健字明确地包含每个子名字空间。我们在例子中会用到I/O流类，因此需要包含System.IO名字空间，我们还需要System.Text名字空间支持字节流的ASCII编码。

由于.NET架构为完成了大部分的工作，编写这一程序所需的步骤相当简单。我们将用到Stream类的BeginRead方法，它提供异步I/O功能，将数据读入到一个缓冲区中，当缓冲区可以处理时调用相应的处理程序。

我们需要使用一个字节数组作为缓冲区和回叫方法的代理，并将这二者定义为驱动程序类的private成员变量。

publicclassAsynchIOTester
{
privateStreaminputStream;
privatebyte[]buffer;
privateAsyncCallbackmyCallBack;


inputStream是一个Stream类型的变量，我们将对它调用BeginRead方法。代理与成员函数的指针非常相似。代理是C#的第一类元素。

当缓冲区被磁盘上的文件填满时，.NET将调用被代理的方法对数据进行处理。在等待读取数据期间，我们可以让计算机完成其他的工作。（在本例中是将1个整型变量由1增加到50000，但在实际的应用程序中，我们可以让计算机与用户进行交互或作其他有意义的工作。）

本例中的代理被定义为AsyncCallback类型的过程，这是Stream的BeginRead方法所需要的。System空间中AsyncCallback类型代理的定义如下所示：

publicdelegatevoidAsyncCallback(IAsyncResultar);


这一代理可以是与任何返回void类型值、将IAsyncResult界面作为参数的方法相关联的。在该方法被调用时，CLR可以在运行时传递IAsyncResult界面对象作为参数。我们需要如下所示的形式定义该方法：

voidOnCompletedRead(IAsyncResultasyncResult)


然后在构造器中与代理连接起来：

AsynchIOTester()
{
???
myCallBack=newAsyncCallback(this.OnCompletedRead);
}


上面的代码将代理的实例赋给成员变量myCallback。下面是全部程序的详细工作原理。在Main函数中，创建了一个类的实例，并让它开始运行：

publicstaticvoidMain()
{
AsynchIOTestertheApp=newAsynchIOTester();
theApp.Run();
}


new关健字能够启动构造器。在构造器中我们打开一个文件，并得到一个Stream对象。然后在缓冲中分配空间并与回调机制联结起来。

AsynchIOTester()
{
inputStream=File.OpenRead("C:\MSDN\fromCppToCS.txt");
buffer=newbyte[BUFFER_SIZE];
myCallBack=newAsyncCallback(this.OnCompletedRead);
}


在Run方法中，我们调用了BeginRead，它将以异步的方式读取文件。

inputStream.BeginRead(
buffer,//存放结果
0,//偏移量
buffer.Length,//缓冲区中有多少字节
myCallBack,//回调代理
null);//本地对象


这时，我们可以完成其他的工作。

for(longi=0;i<50000;i++)
{
if(i%1000==0)
{
Console.WriteLine("i:{0}",i);
}
}


文件读取操作结束后，CLR将调用回调方法。

voidOnCompletedRead(IAsyncResultasyncResult)
{


在OnCompletedRead中要做的第一件事就是通过调用Stream对象的EndRead方法找出读取了多少字节：

intbytesRead=inputStream.EndRead(asyncResult);


对EndRead的调用将返回读取的字节数。如果返回的数字比0大，则将缓冲区转换为一个字符串，然后将它写到控制台上，然后再次调用BeginRead，开始另一次异步读的过程。

if(bytesRead>0)
{
Strings=Encoding.ASCII.GetString(buffer,0,bytesRead);
Console.WriteLine(s);
inputStream.BeginRead(buffer,0,buffer.Length,
myCallBack,null);
}


现在，在读取文件的过程中就可以作别的工作了（在本例中是从1数到50000），但我们可以在每次缓冲区满了时对读取的数据进行处理（在本例中是向控制台输出缓冲区中的数据）。有兴趣的读者可以点击此处下载完整的源代码。

异步I/O的管理完全是由CLR提供的，这样，在网络上读取文件时，会更好些。

在网络上读取文件

在C++中，在网络上读取文件需要有相当的编程技巧，.NET对此提供了广泛的支持。事实上，在网络上读取文件仅仅是基础类库中Stream类的另一种应用。

首先，为了对TCP/IP端口（在本例中是65000）进行监听，我们需要创建一个TCPListener类的实例。

TCPListenertcpListener=newTCPListener(65000);


一旦创建后，就让它开始进行监听。

tcpListener.Start();


现在就要等待客户连接的要求了。

SocketsocketForClient=tcpListener.Accept();


TCPListener对象的Accept方法返回一个Socket对象，Accept是一个同步的方法，除非接收到一个连接请求它才会返回。如果连接成功，就可以开始向客户发送文件了。

if(socketForClient.Connected)
{
???



接下来，我们需要创建一个NetworkStream类，将报路传递给constructor：

NetworkStreamnetworkStream=newNetworkStream(socketForClient);


然后创建一个StreamWriter对象，只是这次不是在文件上而是在刚才创建的NetworkStream类上创建该对象：

System.IO.StreamWriterstreamWriter=
newSystem.IO.StreamWriter(networkStream);


当向该流写内容时，流就通过网络被传输给客户端。

客户端的创建

客户端软件就是一个TCPClient类的具体例子，TCPClient类代表连向主机的一个TCP/IP连接。

TCPClientsocketForServer;
socketForServer=newTCPClient("localHost",65000);


有了TCPClient对象后，我们就可以创建NetworkStream对象了，然后在其上创建StreamReader类：

NetworkStreamnetworkStream=socketForServer.GetStream();
System.IO.StreamReaderstreamReader=
newSystem.IO.StreamReader(networkStream);


现在，只要其中有数据就读取该流，并将结果输出到控制台上。

do
{
outputString=streamReader.ReadLine();

if(outputString!=null)
{
Console.WriteLine(outputString);
}
}
while(outputString!=null);


为了对这一段代码进行测试，可以创建如下一个测试用的文件：

Thisislineone
Thisislinetwo
Thisislinethree
Thisislinefour


这是来自服务器的输出：

Output(Server)
Clientconnected
SendingThisislineone
SendingThisislinetwo
SendingThisislinethree
SendingThisislinefour
Disconnectingfromclient...
Exiting...


下面是来自客户端的输出：

Thisislineone
Thisislinetwo
Thisislinethree
Thisislinefour


属性和元数据

C#和C++之间一个显著的区别是它提供了对元数据的支持：有关类、对象、方法等其他实体的数据。属性可以分为二类：一类以CLR的一部分的形式出现，另一种是我们自己创建的属性，CLR属性用来支持串行化、排列和COM协同性等。一些属性是针对一个组合体的，有些属性则是针对类或界面，它们也被称作是属性目标。

将属性放在属性目标前的方括号内，属性就可以作用于它们的属性目标。

[assembly:AssemblyDelaySign(false)]
[assembly:AssemblyKeyFile(".\\keyFile.snk")]


或用逗号将各个属性分开：

[assembly:AssemblyDelaySign(false),
assembly:AssemblyKeyFile(".\\keyFile.snk")]


自定义的属性

我们可以任意创建自定义属性，并在认为合适的时候使用它们。假设我们需要跟踪bug的修复情况，就需要建立一个包含bug的数据库，但需要将bug报告与专门的修正情况绑定在一块儿，则可能在代码中添加如下所示的注释：

//Bug323fixedbyJesseLiberty1/1/2005.


这样，在源代码中就可以一目了然地了解bug的修正情况，但如果如果把相关的资料保存在数据库中可能会更好，这样就更方便我们的查询工作了。如果所有的bug报告都使用相同的语法那就更好了，但这时我们就需要一个定制的属性了。我们可能使用下面的内容代替代码中的注释：

[BugFix(323,"JesseLiberty","1/1/2005")Comment="Offbyoneerror"]


与C#中的其他元素一样，属性也是类。定制化的属性类需要继承System.Attribute：

publicclassBugFixAttribute:System.Attribute

我们需要让编译器知道这个属性可以跟什么类型的元素，我们可以通过如下的方式来指定该类型的元素：

[AttributeUsage(AttributeTargets.ClassMembers,AllowMultiple=true)]


AttributeUsage是一个作用于属性的属性━━元属性，它提供的是元数据的元数据，也即有关元数据的数据。在这种情况下，我们需要传递二个参数，第一个是目标（在本例中是类成员。），第二个是表示一个给定的元素是否可以接受多于一个属性的标记。AllowMultiple的值被设置为true，意味着类成员可以有多于一个BugFixAttribute属性。如果要联合二个属性目标，可以使用OR操作符连接它们。

[AttributeUsage(AttributeTargets.Class|AttributeTargets.Interface,AllowMultiple=true)]


上面的代码将使一个属性隶属于一个类或一个界面。

新的自定义属性被命名为BugFixAttribute。命名的规则是在属性名之后添加Attribute。在将属性指派给一个元素后，编译器允许我们使用精简的属性名调用这一属性。因此，下面的代码是合法的：

[BugFix(123,"JesseLiberty","01/01/05",Comment="Offbyone")]


编译器将首先查找名字为BugFix的属性，如果没有发现，则查找BugFixAttribute。

每个属性必须至少有一个构造器。属性可以接受二种类型的参数：环境参数和命名参数。在前面的例子中，bugID、编程人员的名字和日期是环境参数，注释是命名参数。环境参数被传递到构造器中的，而且必须按在构造器中定义的顺序传递。

publicBugFixAttribute(intbugID,stringprogrammer,stringdate)
{
this.bugID=bugID;
this.programmer=programmer;
this.date=date;
}

Namedparametersareimplementedasproperties.


属性的使用

为了对属性进行测试，我们创建一个名字为MyMath的简单类，并给它添加二个函数，然后给它指定bugfix属性。

[BugFixAttribute(121,"JesseLiberty","01/03/05")]

[BugFixAttribute(107,"JesseLiberty","01/04/05",
Comment="Fixedoffbyoneerrors")]
publicclassMyMath




这些数据将与元数据存储在一起。下面是完整的源代码及其输出：

自定义属性

usingSystem;
//创建被指派给类成员的自定义属性
[AttributeUsage(AttributeTargets.Class,
AllowMultiple=true)]
publicclassBugFixAttribute:System.Attribute
{
//位置参数的自定义属性构造器
publicBugFixAttribute
(intbugID,
stringprogrammer,
stringdate)
{
this.bugID=bugID;
this.programmer=programmer;
this.date=date;
}
publicintBugID
{
get
{
returnbugID;
}
}

//命名参数的属性
publicstringComment
{
get
{
returncomment;
}
set
{
comment=value;
}
}

publicstringDate
{
get
{
returndate;
}
}

publicstringProgrammer
{
get
{
returnprogrammer;
}
}

//专有成员数据
privateintbugID;
privatestringcomment;
privatestringdate;
privatestringprogrammer;
}

//把属性指派给类

[BugFixAttribute(121,"JesseLiberty","01/03/05")]
[BugFixAttribute(107,"JesseLiberty","01/04/05",
Comment="Fixedoffbyoneerrors")]
publicclassMyMath
{

publicdoubleDoFunc1(doubleparam1)
{
returnparam1+DoFunc2(param1);
}

publicdoubleDoFunc2(doubleparam1)
{
returnparam1/3;
}

}

publicclassTester
{
publicstaticvoidMain()
{
MyMathmm=newMyMath();
Console.WriteLine("CallingDoFunc(7).Result:{0}",
mm.DoFunc1(7));
}
}




输出：

CallingDoFunc(7).Result:9.3333333333333339


象我们看到的那样，属性对输出绝对没有影响，创建属性也不会影响代码的性能。到目前为止，读者也只是在听我论述有关属性的问题，使用ILDASM浏览元数据，就会发现属性确实是存在的。

映射

在许多情况下，我们需要一种方法，能够从元数据中访问属性，C#提供了对映射的支持以访问元数据。通过初始化MemberInfo类型对象，System.Reflection名字空间中的这个对象可以用来发现成员的属性，对元数据进行访问。

System.Reflection.MemberInfoinf=typeof(MyMath);


对MyMath类型调用typeof操作符，它返回一个由继承MemberInfo而生成的Type类型的变量。

下一步是对MemberInfo对象调用GetCustomAttributes，并将希望得到的属性的类型作为一个参数传递给GetCustomAttributes。我们将得到一个对象数组，数组的每个成员的类型都是BugFixAttribute。

object[]attributes;
attributes=Attribute.GetCustomAttributes(inf,typeof(BugFixAttribute));


我们就可以遍历这个数组了，打印BugFixAttribute对象的数组，代码下所示：

属性的打印

publicstaticvoidMain()
{
MyMathmm=newMyMath();
Console.WriteLine("CallingDoFunc(7).Result:{0}",
mm.DoFunc1(7));

//获取成员信息并使用它访问自定义的属性
System.Reflection.MemberInfoinf=typeof(MyMath);
object[]attributes;
attributes=
Attribute.GetCustomAttributes(inf,typeof(BugFixAttribute));

//遍历所有的属性
foreach(Objectattributeinattributes)
{
BugFixAttributebfa=(BugFixAttribute)attribute;
Console.WriteLine("\nBugID:{0}",bfa.BugID);
Console.WriteLine("Programmer:{0}",bfa.Programmer);
Console.WriteLine("Date:{0}",bfa.Date);
Console.WriteLine("Comment:{0}",bfa.Comment);
}
}


类型发现

我们可以通过映象的方法来研究一个组合实体的内容，如果要建立需要显示组合体内部信息的工具或动态地调用组合体中的途径，这一方法是非常有用的。

通过映象的方法，我们可以知道一个模块、方法、域、属性的类型，以及该类型的每个方法的信号、该类支持的界面和该类的超级类。我们可以通过如下的形式，用Assembly.Load静态方法动态地加载一个组合体：

publicstaticAssembly.Load(AssemblyName)


然后，可以将它传递到核心库中。

Assemblya=Assembly.Load("Mscorlib.dll");


一旦加载了组合体，我们可以通过调用GetTypes返回一个Type对象数组。Type对象是映射的核心，它表示类、界面、数组、值和枚举等的类型定义。

Type[]types=a.GetTypes();


组合休会返回一个类型的数组，我们可以使用foreach-loop结构显示该数组，其输出将有好几页文档之多，下面我们从中找一小段：

TypeisSystem.TypeCode
TypeisSystem.Security.Util.StringExpressionSet
TypeisSystem.Text.UTF7Encoding$Encoder
TypeisSystem.ArgIterator
TypeisSystem.Runtime.Remoting.JITLookupTable
1205typesfound


我们得到了一个内容为核心库中类型的数组，可以将它们都打印出来，该数组将有1205个项。

对一种类型映射我们也可以对组合体中一种类型进行映射。为此，我们可以使用GetType方法从组合体中解析出一个类型：

publicclassTester
{
publicstaticvoidMain()
{
//检查一个对象
TypetheType=Type.GetType("System.Reflection.Assembly");
Console.WriteLine("\nSingleTypeis{0}\n",theType);
}
}


输出如下所示：

SingleTypeisSystem.Reflection.Assembly


发现成员

我们还可以得到所有成员的类型，显示所有的方法、属性、域，下面的代码演示了实现上述目标的代码。

Figure9GettingAllMembers
publicclassTester
{
publicstaticvoidMain()
{
//检查一个单一的对象
TypetheType=Type.GetType("System.Reflection.Assembly");
Console.WriteLine("\nSingleTypeis{0}\n",theType);

//获取所有的成员
MemberInfo[]mbrInfoArray=
theType.GetMembers(BindingFlags.LookupAll);
foreach(MemberInfombrInfoinmbrInfoArray)
{
Console.WriteLine("{0}isa{1}",
mbrInfo,mbrInfo.MemberType.Format());
}
}
}


尽管得到的输出还非常长，但在输出中我们可以得到如下面的不甘落后民示的域、方法、构造器和属性：

System.Strings_localFilePrefixisaField
BooleanIsDefined(System.Type)isaMethod
Void.ctor()isaConstructor
System.StringCodeBaseisaProperty
System.StringCopiedCodeBaseisaProperty


只发现方法

我们可能会只关心方法，而不关心域、属性等，为此，我们需要删除如下的对GetMembers的调用：

MemberInfo[]mbrInfoArray=
theType.GetMembers(BindingFlags.LookupAll);


然后添加调用GetMethods的语句：

mbrInfoArray=theType.GetMethods();


现在，输出中就只剩下方法了。

Output(excerpt)
BooleanEquals(System.Object)isaMethod
System.StringToString()isaMethod
System.StringCreateQualifiedName(System.String,System.String)
isaMethod
System.Reflection.MethodInfoget_EntryPoint()isaMethod


发现特定的成员

最后，为了进一步地缩小范围，我们可以使用FindMembers方法来发现某一类型的特定的方法。例如，在下面的代码中，我们可以只搜索以“Get”开头的方法。

publicclassTester
{
publicstaticvoidMain()
{
//检查一个单一的对象
TypetheType=Type.GetType("System.Reflection.Assembly");
//只获取以Get开头的成员
MemberInfo[]mbrInfoArray
theType.FindMembers(MemberTypes.Method,
BindingFlags.Default,
Type.FilterName,"Get*");
foreach(MemberInfombrInfoinmbrInfoArray)
{
Console.WriteLine("{0}isa{1}",
mbrInfo,mbrInfo.MemberType.Format());
}
}
}



其输出的一部分如下所示：

System.Type[]GetTypes()isaMethod
System.Type[]GetExportedTypes()isaMethod
System.TypeGetType(System.String,Boolean)isaMethod
System.TypeGetType(System.String)isaMethod
System.Reflection.AssemblyNameGetName(Boolean)isaMethod
System.Reflection.AssemblyNameGetName()isaMethod
Int32GetHashCode()isaMethod
System.Reflection.AssemblyGetAssembly(System.Type)isaMethod
System.TypeGetType(System.String,Boolean,Boolean)isaMethod


动态调用

一旦发现一个方法，可以使用映射的方法调用它。例如，我们可能需要调用System.Math中的Cos方法（返回一个角的余弦值）。为此，我们需要获得System.Math类的类型信息，如下所示：

TypetheMathType=Type.GetType("System.Math");


有了类型信息，我们就可以动态地加载一个类的实例：

ObjecttheObj=Activator.CreateInstance(theMathType);


CreateInstance是Activator类的一个静态方法，可以用来对对象进行初始化。

有了System.Math类的实例后，我们就可以调用Cos方法了。我们还需要准备好一个定义参数类型的数组，因为Cos只需要一个参数（需要求余弦值的角度），因此数组中只需要有一个成员。我们将在数组中赋予一个System.Double类型的Type对象，也就是Cos方法需要的参数的类型：

Type[]paramTypes=newType[1];
paramTypes[0]=Type.GetType("System.Double");


现在我们就可以传递方法的名字了，这个数组定义了Type对象中GetMethod方法的参数的类型：

MethodInfoCosineInfo=
theMathType.GetMethod("Cos",paramTypes);


我们现在得到了MethodInfo类型的对象，我们可以在其上调用相应的方法。为此，我们需要再次在数组中传入参数的实际值：

Object[]parameters=newObject[1];
parameters[0]=45;
ObjectreturnVal=CosineInfo.Invoke(theObj,parameters);


需要注意的是，我创建了二个数组，第一个名字为paramTypes的数组存储着参数的类型，第二个名字为parameters的数组保存实际的参数值。如果方法需要二个参数，我们就需要使这二个数组每个保持二个参数。如果方法不需要参数，我们仍然需要创建这二个数组，只是无需在里面存储数据即可。

Type[]paramTypes=newType[0];


尽管看起来有点奇怪，但它是正确的。下面是完整的代码：

映射方法的使用

usingSystem;
usingSystem.Reflection;publicclassTester
{
publicstaticvoidMain()
{
TypetheMathType=Type.GetType("System.Math");
ObjecttheObj=Activator.CreateInstance(theMathType);

//只有一个成员的数组
Type[]paramTypes=newType[1];
paramTypes[0]=Type.GetType("System.Double");

//获得Cos()方法的信息
MethodInfoCosineInfo=
theMathType.GetMethod("Cos",paramTypes);

//将实际的参数填写在一个数组中
Object[]parameters=newObject[1];
parameters[0]=45;
ObjectreturnVal=CosineInfo.Invoke(theObj,parameters);
Console.WriteLine(
"Thecosineofa45degreeangle{0}",returnVal);

}
}




结论

尽管有许多小错误等着C++编程人员去犯，但C#的语法与C++并没有太大的不同，向新语言的转换是相当容易的。使用C#的有趣的部分是使用通用语言运行库，这篇文章只能涉及几个重点问题。CLR和.NETFramework提供了对线程、集合、互联网应用开发、基于Windows的应用开发等方面提供了更多的支持。语言功能和CLR功能之间的区分是非常模糊的，但组合在一起就是一种功能非常强大的开发工具了。