荔园在线

荔园之美,在春之萌芽,在夏之绽放,在秋之收获,在冬之沉淀

[回到开始] [上一篇][下一篇]


发信人: Hippy (HI皮), 信区: DotNET
标  题: 由C++转向C#:我们需要注意哪些方面的变化?
发信站: 荔园晨风BBS站 (Fri Jan 11 11:44:31 2002), 转信


建立在C++的语法和语义的,可以让C语言编程人员利用.NET和通用语言运行库带来
的便利。尽管从C++转向C#是相对容易的,但仍然有些地方值得我们注意。在这篇
文章中我们将探索其中的一些新特性,如碎片收集、属性、foreach-loop循环和界
面等。

每隔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<lbt.GetNumEntries();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功能之间
的区分是非常模糊的,但组合在一起就是一种功能非常强大的开发工具了

--
※ 来源:·荔园晨风BBS站 bbs.szu.edu.cn·[FROM: 192.168.32.142]


[回到开始] [上一篇][下一篇]

荔园在线首页 友情链接:深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店