每隔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
本文地址：http://com.8s8s.com/it/it42960.htm