初探c#
/* 1 绪论
c# 是一种简练，时髦（？），面向对象（object oriented），类型可靠（type-safe）的 编程语言。它（发音：C sharp）是从c/c++发展而来的（？俺觉得更象是java），和c/c++是一个语系。所以，很容易被c/c++的程序员接受。c#的目标是结合Visual Basic的高产和C++质朴的力量。
c#将会是vs7的一分子。vs7还支持vb,vc和标记语言——VBScript和JScript。所有这些语言都会在Next Generation Windows Services (NWGS) platform 中得到支持（c#就需要一个NWGS SDK包，可以在m$的网站上下载）。有了这个东东（NWGS），c#就不需要自己的类库，而使用vc或vb这样一些成熟的库。c#也确实没有自己的类库。
废话完了。
1。1 一个老土的例子（就不能换换吗？）*/
/* idontlikeHelloworld.cs : such a out sample :( */
1: using System;
2: class idontlikeHelloworld
3: {
4: static void Main() {
5: Console.WriteLine("i dont like Hello world");
6: Console.ReadLine();
7: }
8: }
/* 如果俺要出书的话，会考虑换个好点的例子。 ^&^
先说说怎样运行。首先，你需要windows2000！（是的，就是它，请各位不要随地丢果皮—— 整个香蕉丢给俺就可以了。）然后，需要NWGS SDK！（82.4mb，不算很大噢。嘿嘿，好在它没有自己的类库。）安装后，在你的程序所在的目录下键入：
csc idontlikeHelloworld.cs (加上一个回车键）
是不是有点复古的味道？这个操作会在和你的*.cs相同目录下产生一个
idontlikeHelloworld.exe文件。双击它，距可以看见：
i dont like Hello world
回车就可以结束它，非常简单。
不过，也可以这样：把它存成后缀为.c的文件更好
（即：idontlikeHelloworld.c）。这样就可以用vc的IDE进行打字，编辑。vc的
txt editor是最棒的噢（又要vc，NO!!!）。然后：
csc idontlikeHelloworld.c (加上一个回车键）
最终效果是完全一样的。
1: using System;
using 其实是c++的关键字，在c#中的含义也相仿（就是说俺还不敢100%肯定，抱歉）。using用在另一个关键字namespace之后。还是先看看namespace。
语法（syntax）：（from MSDN）
namespace [identifier] { namespace-body }
俺的理解：
identifier：在这里就是System（请记住：c#和c/c++一样，是区分大小写的！）。System 必须在使用它的范围内是唯一的。即，不能够有第二个System，但可以有system。 而“它的范围”，俺不想详细解说，只有在实践中才可能掌握。而且，初学者根本不必知道！俺也是近来才知道还有个namespace和using。 ：）
在{ namespace-body }中的是真正有用的东东，包括第五行的"nsole.WriteLine"的声明和定义（后面还会提到）。System是由NWGS定义的，咱们只需用（using）它即可。至于System在什么文件里定义，咱就不用管了！交给编译器（就是刚才那个“csc.exe”）去寻找。这就代替了c/c++中的“#include”，可以说是近了一步，避免大量烦人的细节。如果你没学过c/c++，就不用理会。namespace 在后面还会谈到。
2: class idontlikeHelloworld
class：是c语系中另一个关键字“类”。表示一系列的特性（官方说法：属性）和行为方法，有了它你的程序就可以“另类”，创造与别不同的有你特色的东东噢！在这里，俺就定义了“idontlikeHelloworld”。注意：这也是c#强制的，对于每一个可执行的程序都必须有。你想干的事就可以记录在紧跟着你定义的class后面的一对花括号。注意：“{”和“}”一一对应的，“(”和“)”同样。
4: static void Main() {
Main()是本例子第一个动作（行为方法），干的第一件事。它是属于俺定义的idontlikeHelloworld类的方法。并且是c#强制的，是程序的真正开始！在紧跟在它后面的“{}”中的语句顺序，就是程序的运行顺序！本例中只有一行（第六行干嘛用？你可以去掉再编译一次看看），输出一句话。
5: Console.WriteLine("i dont like Hello world");
非常奇怪，Console（再次提醒：注意大小写）不是俺定义的，从何而来？它其实是属于Systemnamespace 的一个class。WriteLine()是Console类中的一个方法，用来显示一句话（字符串）。
这里只是用了这个方法的1/18！并且是最简单之一！其他的有机会再说。你也可以用
“Console.WriteLine”在“NGWS SDK Documentaion”中搜索“Console.WriteLine”，记住复选“仅搜索标题”，它会列出19项。好啦，完了！其实，还有“.”没说呢！呵呵...lei si la!!!!
语句不通顺，俺会在以后改进（update），敬请原谅！--“请先用叉子喝汤”
/* idontlikeHelloworld.cs */
1: //using System;
2: class idontlikeHelloworld
3: {
4: static void Main() {
5: System.Console.WriteLine("i dont like Hello world");
6: System.Console.ReadLine();
7: }
8: }
/* 看见了，当俺注销掉“using System;”后，在第五行和第六行加了“System”。程序的结果不会改变。但是，很明显的这样比较罗嗦，所以引入了“namespace”。 其实，class应该可以完成同样的功能。
不过，设计者可能不想让一个关键字涵盖太多的功能。记得在c向c++发展的时候，引入了“class”，而不是扩展“struct”关键字的功能；又比如“=”只用于赋值，“==”只用于判断相等。这是c/c++和c#在语法上其中一个重要的特点。这样设计的好处很多。有机会再聊噢。
如果你没学过c/c++，以下的内容可以跳过。c#与c/c++在语法上还是有区别的，比如：
1。c#根本没有“::”；“->”只在程序中很小的片断中。在c#中应采用“.”。
2。c#无须先声明定义，再使用。与java相同。
3。c#取消了用“#include”导入其他的程序文本文件，而采用象征性的句柄引入他人的代码。这样一来，就排除了编程语言间的障碍，方便地使用其它语言编写的库。如“Console”类可以是c#或者是其他任一种语言编写的。
1。2 自动化的内存管理（Automatic memory management）
手动管理内存需要程序员自行分配和释放内存块。这要求程序员有清晰的头脑和对整个运行过程有十分的把握（好难！）。而c#把程序员从这难以承担的任务中解放出来。在多数的情况下，这种自动内存管理提高代码的质量和程序员的生产力。并且，不会对程序的意图和执行产生幅面的影响（？俺可不相信m$的鬼话）。不过，估计比java的回收站好一点吧。因为c#出道迟嘛（尽胡扯）。
好了，来看看例子。*/
using System;
public class Stack
{
private Node first = null;
public bool Empty {
get {
return (first == null);
}
}
public object Pop() {
if (first == null)
throw new Exception("Can't Pop from an empty Stack.");
else {
object temp = first.Value;
first = first.Next;
return temp;
}
}
public void Push(object o) {
first = new Node(o, first);
}
class Node
{
public Node Next;
public object Value;
public Node(object value): this(value, null) {}
public Node(object value, Node next) {
Next = next;
Value = value;
}
}
}
class Test
{
static void Main() {
Stack s = new Stack();
for (int i = 0; i < 10; i++)
s.Push(i);
while (!s.Empty)
Console.WriteLine(s.Pop());
}
}
/*
stack类实现了一系列Node的实例。大家可以看看stack类的Push方法。Node的实例就是在Push方法中创建的。
就是“first = new Node(o, first);”。请记住这个“new”噢。它就是用来创建类实例的。相关的语法太多，遛到后面用一节详细讲。这里只是要了解自动内存管理（Automatic memory management）好处？！“new”是负责初始化类实例。而在c/c++中释放这些实例要用另一个关键字“delete”。但是在什么时候用delete呢，这通常是很费神的活，老手也会阴沟里翻船。何况是俺呢！但在c#中有不用了。例子里就没有用“delete”。
当Node的实例不需要时，垃圾收集器（garbage collector）自动销毁它，不用俺操心喽。这点到和java挺像的（可能是抄的）。
这个例子相当的好，是stack的一个典型，也很好的表述了自动内存管理的机制。但也不好懂，好在这一节不是写给毫无基础的网友看的。
俺自个都花了几分钟看明白，各位大虾更是没问题。
其实，当显示完了“10”以后，就会有一个Node的实例符合被释放的条件，但垃圾收集器并不一定会这样做。
也就是说，它的行为并不确定（这和java一样，俺猜）。有时候，这种行为会带来一些负面影响。起码是性
能降低。自动内存管理本身也是有问题的。因为它很难管理一些特殊情况。有一些关于java的垃圾收集器的
文章也有提到。m$也不会好得了多少。所以，m$有个不安全代码的术语（unsafe code），用来为高级用户服
务。即，用户可以不采用垃圾收集器。但必须用“unsafe”关键字显式声明之。这样就避免了用户不经意以
外使用不安全代码。下面是一个例子：*/
using System;
class Test
{
unsafe static void WriteLocations(byte[] arr) {
fixed (byte *p_arr = arr) {
byte *p_elem = p_arr;
for (int i = 0; i < arr.Length; i++) {
byte value = *p_elem;
string addr = int.Format((int) p_elem, "X");
Console.WriteLine("arr[{0}] at 0x{1} is {2}", i, addr, value);
p_elem++;
}
}
}
static void Main() {
byte[] arr = new byte[] {1, 2, 3, 4, 5};
WriteLocations(arr);
}
}
/*
俺对这个例子不是很满意，也让俺有点迷惑，有机会再自己写一个。很简单，只是可以用指针了！万岁！
其实，俺对这一节最没有把握了！有不少地方都不能自圆其说！所以，请各位大虾大力批评。*/
1。3 类型
c#支持两种基本的类型：一种是值（value types），一种是引用（reference types）。值包括简单类型（char、int、和float），枚举（enum）和结构（struct）。引用包括类（class），界面（interface），代表（delegate）和数组阵列（array）。值与引用不同之处在于：值直接存储它的数据内容；而引用存储对象
的引用。是不是粉费解？！打个比方吧。你在某地买了套别墅（好棒噢）。却从未去过，只知道地址，怎么办？你可以坐出租车，司机看了地址就知道怎样走不用你操心。你手里的地址就好像对象的名字，你把它写在程序中，就好像把地址给了司机。司机就是你的编译器，它知道该去哪。你豪华的房子就好比那个NGWS SDK开发包（82mb噢，够豪华了！俺的m啊--就这样烧喽）。房子里有你想要的东东，比如你想写一句话（i dont like Hello world），就好像上面例子，要用到“WriteLine”。于是，你就给出“WriteLine”的地址，比如：“Console.WriteLine”。明白？！俺可累了。zzz... （强打精神）不知道你想到没有，值和引用的区别可以引出一个重要特性。值的变量和变量存储的数据是一一对应的，唯一性。而引用则不然。引用中不同的变量可以引用同一个对象的实例。当其中一个变量改变实例的值时，其他引用这个实例的变量也会受到影响（当然，变量本身并没有改变，即，地址没变）。瞧，变量只是说明存储对象的位置（地址），而不是对象本身。就好像你漂亮的房子被烧了，但你的地址并没有改变，但地址对应的房子就没了。
也许是别人也有这个地址，他去烧了你的房子！好了，在给个例子：*/
1: using System;
2: class CValue
3: {
4: public int Value = 0;
5: }
6: class Test
7: {
8: static void Main() {
9: int val1 = 0;
10: int val2 = val1;
11: val2 = 123;
12: CValue ref1 = new CValue();
13: CValue ref2 = ref1;
14: ref2.Value = 123;
15: Console.WriteLine("Values: {0}, {1}", val1, val2);
16: Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
17: }
18: }
/* 下面是输出的结果：
Values: 0, 123
Refs: 123, 123
啊哈，应该粉清楚了吧。变量val1和变量val2互不影响,它们各自有自己的存储空间。而ref2复制了ref1，所以，它们引用了同一个对象的实例。当改变它们其中一个的时候，就会影响到另一个的值。
1。4 预定义类型（Predefined types）
c#提供了一系列预定义类型。它们与c/c++有不少相似的地方。预定义引用类型有object和string。object类型是所有其他类型的基础。
预定义类型包括符号数、无符号数、浮点、布尔、字符和十进制数。符号数有：
sbyte、short、
int和long；
无符号数有：byte、ushort、uint和ulong；
浮点数有：float和double。
布尔类型就像一个开关，只有两种状态：true或false。c#对布尔的要求比c/c++严格，与java类似。
在c#中false不等于0，true也不等于1；false和true都是单独分离出来的一个值。学过c/c++的网友都知道：
*/
int i = 0;
if (i = 0) { // Bug: 应该是 (i == 0)
....
}
/*
是没有问题的。但在c#中会引发一个编译错误（error CS0029: Cannot implicitly converttype 'int' to 'bool'）。当然，这样牺牲了一点没有必要的灵活性。我们再也不能这样：
*/
string str;
....
if(str = Console.ReadLine()) {
Console.WriteLine("Your comments are: {0}",str);
....
/*
而必须：
*/
using System;
class BoolTest
{
static void Main() {
string str = Console.ReadLine();//也可以：string str;
if(str == "") // if((str = Console.ReadLine()) == "")
Console.WriteLine("i can't read your comments. Please tell me something! O.K.?");
else
Console.WriteLine("Your comments are: {0}",str);
}
}
/*
Type Description Examples
object The ultimate base type of all other types object o = new Stack();
string String type; a string is a sequence of string s = "Hello";
Unicode characters
sbyte 8-bit signed integral type sbyte val = 12;
short 16-bit signed integral type short val = 12;
int 32-bit signed integral type int val = 12;
long 64-bit signed integral type long val1 = 12;
long val2 = 34L;
byte 8-bit unsigned integral type byte val1 = 12;
byte val2 = 34U;
ushort 16-bit unsigned integral type ushort val1 = 12;
ushort val2 = 34U;
uint 32-bit unsigned integral type uint val1 = 12;
uint val2 = 34U;
ulong 64-bit unsigned integral type ulong val1 = 12;
ulong val2 = 34U;
ulong val3 = 56L;
ulong val4 = 78UL;
float Single-precision floating point type float value = 1.23F;
double Double-precision floating point type double val1 = 1.23
double val2 = 4.56D;
bool Boolean type; a bool value is either bool value = true;
true or false
char Character type; a char value is a Unicode char value = 'h';
character
decimal Precise decimal type with 28 significant digits decimal value = 1.23M;
你也可以自定义自己的预定义类型，可以这样：
*/
using System;
struct Digit
{...}
class Test
{
static void TestInt() {
int a = 1;
int b = 2;
int c = a + b;
Console.WriteLine(c);
}
static void TestDigit() {
Digit a = (Digit) 1;
Digit b = (Digit) 2;
Digit c = a + b;
Console.WriteLine(c);
}
static void Main() {
TestInt();
TestDigit();
}
}
/*
这一节有点沉闷。：（
1.6 统一系统类型（Type system unification）
c#独创了一种类型——统一系统类型（为了这个累刑，我头疼死了。谁有更好的名字，请务必告诉我）。总之，所有的其他类型，包括值和引用，都可以被当作统一系统类型来对待。从概念上说，所有的类型都从它派生。这样，其他的类型就可以使用统一系统类型的属性和方法。包括一些“简单”类型，如：int。还是给个例子吧：
*/
using System;
class Test
{
static void Main() {
Console.WriteLine(3.ToString());
}
}
/*
“3.ToString()”调用了object的“ToString()”方法。相信学过c/c++的朋友都知道要输出一个数字有多麻烦，现在就省事了。再看一个：*/
class Test
{
static void Main() {
int i = 123;
object o = i; // boxing
int j = (int) o; // unboxing
}
}
/*
这个像帽子戏法的例子中，从“int”转换成“object”，又转换回来。这样一来，在值和引用之间就架起了一座桥梁。
// c/c++ code
void min(int i, int j)
{
return ((i < j) ? i : j);
}
/* 如果比较的不是int，或者说可能是int，也可能是float、double呢？可以这样：*/
template
T min (T i, T j)
{
return ((i < j) ? i : j)
}
/* 用c#可以：*/
void swap (object a, object b)
{
return ((i < j) ? i : j);
}
/*
我想大家一定看出来第二个例子要比较一个int和一个float的话，还需要一些转换，而第三个例子就可以比较所有的变量！这个灵活度简直太大了。所以，我私以为，大家使用时一定要小心！
它在比较一个int和一个class的时候决不会报错的。呵呵，我发现我的翻译总是越跑越远，总是扣不住原文。篡改甚多，敬请原谅！
1.7 语句（Statements）
c#借用了c/c++大多数的语句方法，不过仍然有些值得注意的地方。还有些地方是有所改动的。在这里，我只提一些c#特有的东东。
1.7.10 “foreach”语句
“foreach”语句列举一个集合内的所有元素，并对这些元素执行一系列的操作。还是看看例子吧：*/
using System;
using System.Collections;
class Test
{
static void WriteList(ArrayList list) {
foreach (object o in list)
{
int i = (int) o;//如果是for语句，这里一定会报错！
Console.WriteLine(0);
Console.WriteLine(++i);
}
}
static void Main() {
ArrayList list = new ArrayList();
for (int i = 0; i < 10; i++)
list.Add(i);
WriteList(list);
}
}
/*这个例子用“foreach”扫描了整个“list”，并把“list”中所有的元素打印出来。有时候还是挺方便的。
1.7.15 安全检查开关（The checked and unchecked statements）
“checked”和“unchecked”语句用来控制数学运算和完整类型转换的检查工作。“checked”检查它作用的域中可能出现的违例，并抛出一个异常；而“unchecked”则阻止所有的检查。举个例子：*/
using System;
class Test
{
static int x = 1000000;
static int y = 1000000;
static int F() {
checked {return (x * y);} // 抛出 OverflowException
}
static int G() {
unchecked {return (x * y);} // 返回 -727379968
}
static int H() {
return x * y; // 缺省状?
}
static void Main() {
F(); //可以注销掉此行试试。
Console.WriteLine(G());
Console.WriteLine(H());
}
}
/*
在编译过程中不会有任何错误出现。因为“checked”和“unchecked”只在运行时才起作用。值得一说的是H()。它的缺省状态和编译器当前的缺省溢出检查的状态有关。但返回的结果肯定和F()或G()中的任一个相同。
using System;
class Test
{
const int x = 1000000;
const int y = 1000000;
static int F() {
checked {return (x * y);} // 编译器警告（Compile warning）：溢出（overflow）
}
static int G() {
unchecked {return (x * y);} // 返回 -727379968
}
static int H() {
return x * y; // 编译器警告（Compile warning）：溢出（overflow）
}
static void Main() {
Console.WriteLine(F()); //可以注销掉此行试试。
Console.WriteLine(G());
Console.WriteLine(H()); //可以注销掉此行试试。
}
}
/* 当F()和H()求值的时候，就会引起一个编译警告。而在G()中，因为有了“unchecked”，屏蔽了这个警
告。要注意的是“checked”和“unchecked”都不能对函数的返回值进行操作！比如：*/
class Test
{
static int Multiply(int x, int y) {
return x * y;
}
static int F() {
checked{ return Multiply(1000000, 1000000); } // 与 return Multiply(1000000, 1000000);
} // 有相同的效果。
}
/* 其实大家稍微想一下知道为什么m$没有这么做！对这个内容的讨论超出本文的范围和俺的能力之外哦。
在c#中，所有的十六进制数都是uint。如果用强制类型转换会引起编译器报错。用“unchecked”则可以跳过这个机制，把uint的十六进制数转化为int。如：*/
class Test
{
public const int AllBits = unchecked((int)0xFFFFFFFF);
public const int HighBit = unchecked((int)0x80000000);
}
/* 上例所有的常数都是uint，而且超过了int的范围，没有“unchecked”，这种转换会引发一个编译器错误。注意：上面用的是“unchecked”操作符。不是语句。不过它们之间除了一个用“()”，另一个用“{}”以外，几乎一样。BTW，“checked”同样。
1.7.16 “lock”语句（The lock statement）
“lock”获得一个相互排斥的对象锁定。（俺查过一些资料，但都没有清晰说明，暂不介绍）
1.8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
· “public” 可以被所有代码访问；
· “protected” 只可以被继承类访问；
· “internal” 只可以被同一个项目的代码访问;
· “protected internal”只可以被同一个项目的代码或继承类访问；
· “private” 只可以被本类中的代码访问。
缺省状态是“private”。
1.9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100个points。在类“Point”中需要分配101个独立的对象（object）。*/
class Point
{
public int x, y;
public Point() {
x = 0;
y = 0;
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
class Test
{
static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
points[i] = new Point(i, i*i);
}
}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译了 ^_^ ）。
1.10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
interface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
interface IControl
{
void Paint();
}
interface ITextBox: IControl
{
void SetText(string text);
}
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”和“IControl”继承。
*/
interface IDataBound
{
void Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
public void Paint();
public void Bind(Binder b) {...}
}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都以“public”的身份在“EditBox”类中实现。
1.10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
interface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
interface IControl
{
void Paint();
}
interface ITextBox: IControl
{
void SetText(string text);
}
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”和“IControl”继承。
*/
interface IDataBound
{
void Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
public void Paint();
public void Bind(Binder b) {...}
}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都以“public”的身份在“EditBox”类中实现。
1.11 枚举（Enums）
枚举声明为一组属性相同的常量定义一个统一的类别名字。它常用于一些在编译时已知范围的常量。但这些常量的具体值要在执行时才能确定。比如，已知三原色是红蓝绿，它们同属于颜色。可以定义如下：
*/
enum Color {
Red,
Blue,
Green
}
/*
我们创建一个shape（形体）类，每一个形体都会有颜色。颜色是属于“shape”的属性。但具体的颜色就要在执行时才能决定：
*/
class Shape
{
public void Fill(Color color) {
switch(color) {
case Color.Red:
...
break;
case Color.Blue:
...
break;
case Color.Green:
...
break;
default:
break;
}
}
}
/*
这个File方法地说明了如何将一种给定的颜色赋予shape类。枚举比起普通整数常量的优胜之处在于：它使得代码更容易阅读理解和更安全。枚举的常量可以由编译器决定。使用时编译器还可以检查它的有效性。枚举其实不是c#特有的。嘿嘿，我就不详细介绍喽。趁机投篮！如果有人感兴趣——自己看书！（为了避免香蕉吃的太多就介绍本书《c语言编程常见问题解答》清华1996。29.00人民币。虽然古老，俺在书店还能见到）
1.12 名字空间（Namespaces）
我们在前面已对namespace花了不少笔墨（俺都忘了该如何接上了！O.K.请大家看完再倒）。我们曾经说“i not
like the hello world”。但是在程序中要经常说就会很累，如果要在别的代码中用就更繁了，这时可以用
namespace搭救。我把第一个例子切开，代码如下：*/
namespace MyOpinion
{
public class Message
{
public string GetMessage() {
return "i dont like Hello world";
}
}
}
/*
如果我想用namespace建立一个自己的库，就要对我的自定义函数和类进行分类，并填入相应的namespace中。
如：*/
namespace Mylib.Csharp.MyOpinion
{
public class Message
{
public string GetMessage() {
return "i dont like Hello world";
}
}
}
/*
namespace是分等级的，“Mylib.Csharp.MyOpinion”其实是缩写，每个“.”后面的namespace都被它前面的包
含。如果拆开：*/
namespace Mylib
{
namespace Csharp
{
namespace MyOpinion
{....}
}
}
/*
然后，我们就可以用自己的库了：*/
using Mylib.Csharp.MyOpinion;
class test
{
static void Main() {
Message m = new Message();
System.Console.WriteLine(m.GetMessage());
}
}
/*
不过无论我们命名如何小心都会出现重名，即命名冲突。这时可以用别名来解决，比如上面的代码可以这样：*/
using MessageSource = Mylib.Csharp.MyOpinion;
class test
{
static void Main() {
MessageSource m = new MessageSource();
System.Console.WriteLine(m.GetMessage());
}
}
1.14 属性（Properties）
关于属性就不用多说了。可能有点特别的是如何得到一个属性和设置一个属性。请诸位看下例：*/
public class Button: Control
{
private string caption;
public string Caption {
get {
return caption;
}
set {
caption = value;
Repaint();
}
}
}
/*
有了上面的定义，我们就可以对Button进行读取和设置它的Caption属性：*/
Button b = new Button();
b.Caption = "ABC"; // 设置
string s = b.Caption; // 读取
b.Caption += "DEF”; // 读取 & 设置
c# 是一种简练，时髦（？），面向对象（object oriented），类型可靠（type-safe）的 编程语言。它（发音：C sharp）是从c/c++发展而来的（？俺觉得更象是java），和c/c++是一个语系。所以，很容易被c/c++的程序员接受。c#的目标是结合Visual Basic的高产和C++质朴的力量。
c#将会是vs7的一分子。vs7还支持vb,vc和标记语言——VBScript和JScript。所有这些语言都会在Next Generation Windows Services (NWGS) platform 中得到支持（c#就需要一个NWGS SDK包，可以在m$的网站上下载）。有了这个东东（NWGS），c#就不需要自己的类库，而使用vc或vb这样一些成熟的库。c#也确实没有自己的类库。
废话完了。
1。1 一个老土的例子（就不能换换吗？）*/
/* idontlikeHelloworld.cs : such a out sample :( */
1: using System;
2: class idontlikeHelloworld
3: {
4: static void Main() {
5: Console.WriteLine("i dont like Hello world");
6: Console.ReadLine();
7: }
8: }
/* 如果俺要出书的话，会考虑换个好点的例子。 ^&^
先说说怎样运行。首先，你需要windows2000！（是的，就是它，请各位不要随地丢果皮—— 整个香蕉丢给俺就可以了。）然后，需要NWGS SDK！（82.4mb，不算很大噢。嘿嘿，好在它没有自己的类库。）安装后，在你的程序所在的目录下键入：
csc idontlikeHelloworld.cs (加上一个回车键）
是不是有点复古的味道？这个操作会在和你的*.cs相同目录下产生一个
idontlikeHelloworld.exe文件。双击它，距可以看见：
i dont like Hello world
回车就可以结束它，非常简单。
不过，也可以这样：把它存成后缀为.c的文件更好
（即：idontlikeHelloworld.c）。这样就可以用vc的IDE进行打字，编辑。vc的
txt editor是最棒的噢（又要vc，NO!!!）。然后：
csc idontlikeHelloworld.c (加上一个回车键）
最终效果是完全一样的。
好，现在分析语法：（c#在语法上完全没有新意 :-| ）
1: using System;
using 其实是c++的关键字，在c#中的含义也相仿（就是说俺还不敢100%肯定，抱歉）。using用在另一个关键字namespace之后。还是先看看namespace。
语法（syntax）：（from MSDN）
namespace [identifier] { namespace-body }
俺的理解：
identifier：在这里就是System（请记住：c#和c/c++一样，是区分大小写的！）。System 必须在使用它的范围内是唯一的。即，不能够有第二个System，但可以有system。 而“它的范围”，俺不想详细解说，只有在实践中才可能掌握。而且，初学者根本不必知道！俺也是近来才知道还有个namespace和using。 ：）
在{ namespace-body }中的是真正有用的东东，包括第五行的"nsole.WriteLine"的声明和定义（后面还会提到）。System是由NWGS定义的，咱们只需用（using）它即可。至于System在什么文件里定义，咱就不用管了！交给编译器（就是刚才那个“csc.exe”）去寻找。这就代替了c/c++中的“#include”，可以说是近了一步，避免大量烦人的细节。如果你没学过c/c++，就不用理会。namespace 在后面还会谈到。
2: class idontlikeHelloworld
class：是c语系中另一个关键字“类”。表示一系列的特性（官方说法：属性）和行为方法，有了它你的程序就可以“另类”，创造与别不同的有你特色的东东噢！在这里，俺就定义了“idontlikeHelloworld”。注意：这也是c#强制的，对于每一个可执行的程序都必须有。你想干的事就可以记录在紧跟着你定义的class后面的一对花括号。注意：“{”和“}”一一对应的，“(”和“)”同样。
4: static void Main() {
Main()是本例子第一个动作（行为方法），干的第一件事。它是属于俺定义的idontlikeHelloworld类的方法。并且是c#强制的，是程序的真正开始！在紧跟在它后面的“{}”中的语句顺序，就是程序的运行顺序！本例中只有一行（第六行干嘛用？你可以去掉再编译一次看看），输出一句话。
5: Console.WriteLine("i dont like Hello world");
非常奇怪，Console（再次提醒：注意大小写）不是俺定义的，从何而来？它其实是属于Systemnamespace 的一个class。WriteLine()是Console类中的一个方法，用来显示一句话（字符串）。
这里只是用了这个方法的1/18！并且是最简单之一！其他的有机会再说。你也可以用
“Console.WriteLine”在“NGWS SDK Documentaion”中搜索“Console.WriteLine”，记住复选“仅搜索标题”，它会列出19项。好啦，完了！其实，还有“.”没说呢！呵呵...lei si la!!!!
语句不通顺，俺会在以后改进（update），敬请原谅！--“请先用叉子喝汤”
“.”被称为分隔符（separator），用来连接名字，如上面"Console.WriteLine"，就把类和它的方法连接。通过这种方式，咱们就可以使用现成方法集合。这里再回顾一下俺的例子，看看namespace和“.”是如何连用的，还有为什么要使用namespace这个关键字。把例子稍微改一下：
/* idontlikeHelloworld.cs */
1: //using System;
2: class idontlikeHelloworld
3: {
4: static void Main() {
5: System.Console.WriteLine("i dont like Hello world");
6: System.Console.ReadLine();
7: }
8: }
/* 看见了，当俺注销掉“using System;”后，在第五行和第六行加了“System”。程序的结果不会改变。但是，很明显的这样比较罗嗦，所以引入了“namespace”。 其实，class应该可以完成同样的功能。
不过，设计者可能不想让一个关键字涵盖太多的功能。记得在c向c++发展的时候，引入了“class”，而不是扩展“struct”关键字的功能；又比如“=”只用于赋值，“==”只用于判断相等。这是c/c++和c#在语法上其中一个重要的特点。这样设计的好处很多。有机会再聊噢。
如果你没学过c/c++，以下的内容可以跳过。c#与c/c++在语法上还是有区别的，比如：
1。c#根本没有“::”；“->”只在程序中很小的片断中。在c#中应采用“.”。
2。c#无须先声明定义，再使用。与java相同。
3。c#取消了用“#include”导入其他的程序文本文件，而采用象征性的句柄引入他人的代码。这样一来，就排除了编程语言间的障碍，方便地使用其它语言编写的库。如“Console”类可以是c#或者是其他任一种语言编写的。
1。2 自动化的内存管理（Automatic memory management）
手动管理内存需要程序员自行分配和释放内存块。这要求程序员有清晰的头脑和对整个运行过程有十分的把握（好难！）。而c#把程序员从这难以承担的任务中解放出来。在多数的情况下，这种自动内存管理提高代码的质量和程序员的生产力。并且，不会对程序的意图和执行产生幅面的影响（？俺可不相信m$的鬼话）。不过，估计比java的回收站好一点吧。因为c#出道迟嘛（尽胡扯）。
好了，来看看例子。*/
using System;
public class Stack
{
private Node first = null;
public bool Empty {
get {
return (first == null);
}
}
public object Pop() {
if (first == null)
throw new Exception("Can't Pop from an empty Stack.");
else {
object temp = first.Value;
first = first.Next;
return temp;
}
}
public void Push(object o) {
first = new Node(o, first);
}
class Node
{
public Node Next;
public object Value;
public Node(object value): this(value, null) {}
public Node(object value, Node next) {
Next = next;
Value = value;
}
}
}
class Test
{
static void Main() {
Stack s = new Stack();
for (int i = 0; i < 10; i++)
s.Push(i);
while (!s.Empty)
Console.WriteLine(s.Pop());
}
}
/*
stack类实现了一系列Node的实例。大家可以看看stack类的Push方法。Node的实例就是在Push方法中创建的。
就是“first = new Node(o, first);”。请记住这个“new”噢。它就是用来创建类实例的。相关的语法太多，遛到后面用一节详细讲。这里只是要了解自动内存管理（Automatic memory management）好处？！“new”是负责初始化类实例。而在c/c++中释放这些实例要用另一个关键字“delete”。但是在什么时候用delete呢，这通常是很费神的活，老手也会阴沟里翻船。何况是俺呢！但在c#中有不用了。例子里就没有用“delete”。
当Node的实例不需要时，垃圾收集器（garbage collector）自动销毁它，不用俺操心喽。这点到和java挺像的（可能是抄的）。
在一个test类里，俺用了一个循环，对stack类的实例的Push方法赋值十次。于是，Push创建了Node的十个实例（instance）。然后用Pop把它们显示出来。其顺序正好与创建的顺序相反。
这个例子相当的好，是stack的一个典型，也很好的表述了自动内存管理的机制。但也不好懂，好在这一节不是写给毫无基础的网友看的。
俺自个都花了几分钟看明白，各位大虾更是没问题。
其实，当显示完了“10”以后，就会有一个Node的实例符合被释放的条件，但垃圾收集器并不一定会这样做。
也就是说，它的行为并不确定（这和java一样，俺猜）。有时候，这种行为会带来一些负面影响。起码是性
能降低。自动内存管理本身也是有问题的。因为它很难管理一些特殊情况。有一些关于java的垃圾收集器的
文章也有提到。m$也不会好得了多少。所以，m$有个不安全代码的术语（unsafe code），用来为高级用户服
务。即，用户可以不采用垃圾收集器。但必须用“unsafe”关键字显式声明之。这样就避免了用户不经意以
外使用不安全代码。下面是一个例子：*/
using System;
class Test
{
unsafe static void WriteLocations(byte[] arr) {
fixed (byte *p_arr = arr) {
byte *p_elem = p_arr;
for (int i = 0; i < arr.Length; i++) {
byte value = *p_elem;
string addr = int.Format((int) p_elem, "X");
Console.WriteLine("arr[{0}] at 0x{1} is {2}", i, addr, value);
p_elem++;
}
}
}
static void Main() {
byte[] arr = new byte[] {1, 2, 3, 4, 5};
WriteLocations(arr);
}
}
/*
俺对这个例子不是很满意，也让俺有点迷惑，有机会再自己写一个。很简单，只是可以用指针了！万岁！
其实，俺对这一节最没有把握了！有不少地方都不能自圆其说！所以，请各位大虾大力批评。*/
1。3 类型
c#支持两种基本的类型：一种是值（value types），一种是引用（reference types）。值包括简单类型（char、int、和float），枚举（enum）和结构（struct）。引用包括类（class），界面（interface），代表（delegate）和数组阵列（array）。值与引用不同之处在于：值直接存储它的数据内容；而引用存储对象
的引用。是不是粉费解？！打个比方吧。你在某地买了套别墅（好棒噢）。却从未去过，只知道地址，怎么办？你可以坐出租车，司机看了地址就知道怎样走不用你操心。你手里的地址就好像对象的名字，你把它写在程序中，就好像把地址给了司机。司机就是你的编译器，它知道该去哪。你豪华的房子就好比那个NGWS SDK开发包（82mb噢，够豪华了！俺的m啊--就这样烧喽）。房子里有你想要的东东，比如你想写一句话（i dont like Hello world），就好像上面例子，要用到“WriteLine”。于是，你就给出“WriteLine”的地址，比如：“Console.WriteLine”。明白？！俺可累了。zzz... （强打精神）不知道你想到没有，值和引用的区别可以引出一个重要特性。值的变量和变量存储的数据是一一对应的，唯一性。而引用则不然。引用中不同的变量可以引用同一个对象的实例。当其中一个变量改变实例的值时，其他引用这个实例的变量也会受到影响（当然，变量本身并没有改变，即，地址没变）。瞧，变量只是说明存储对象的位置（地址），而不是对象本身。就好像你漂亮的房子被烧了，但你的地址并没有改变，但地址对应的房子就没了。
也许是别人也有这个地址，他去烧了你的房子！好了，在给个例子：*/
1: using System;
2: class CValue
3: {
4: public int Value = 0;
5: }
6: class Test
7: {
8: static void Main() {
9: int val1 = 0;
10: int val2 = val1;
11: val2 = 123;
12: CValue ref1 = new CValue();
13: CValue ref2 = ref1;
14: ref2.Value = 123;
15: Console.WriteLine("Values: {0}, {1}", val1, val2);
16: Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
17: }
18: }
/* 下面是输出的结果：
Values: 0, 123
Refs: 123, 123
啊哈，应该粉清楚了吧。变量val1和变量val2互不影响,它们各自有自己的存储空间。而ref2复制了ref1，所以，它们引用了同一个对象的实例。当改变它们其中一个的时候，就会影响到另一个的值。
1。4 预定义类型（Predefined types）
c#提供了一系列预定义类型。它们与c/c++有不少相似的地方。预定义引用类型有object和string。object类型是所有其他类型的基础。
预定义类型包括符号数、无符号数、浮点、布尔、字符和十进制数。符号数有：
sbyte、short、
int和long；
无符号数有：byte、ushort、uint和ulong；
浮点数有：float和double。
布尔类型就像一个开关，只有两种状态：true或false。c#对布尔的要求比c/c++严格，与java类似。
在c#中false不等于0，true也不等于1；false和true都是单独分离出来的一个值。学过c/c++的网友都知道：
*/
int i = 0;
if (i = 0) { // Bug: 应该是 (i == 0)
....
}
/*
是没有问题的。但在c#中会引发一个编译错误（error CS0029: Cannot implicitly converttype 'int' to 'bool'）。当然，这样牺牲了一点没有必要的灵活性。我们再也不能这样：
*/
string str;
....
if(str = Console.ReadLine()) {
Console.WriteLine("Your comments are: {0}",str);
....
/*
而必须：
*/
using System;
class BoolTest
{
static void Main() {
string str = Console.ReadLine();//也可以：string str;
if(str == "") // if((str = Console.ReadLine()) == "")
Console.WriteLine("i can't read your comments. Please tell me something! O.K.?");
else
Console.WriteLine("Your comments are: {0}",str);
}
}
/*
我抄了一张预定义类型的简表供大家参考。
Type Description Examples
object The ultimate base type of all other types object o = new Stack();
string String type; a string is a sequence of string s = "Hello";
Unicode characters
sbyte 8-bit signed integral type sbyte val = 12;
short 16-bit signed integral type short val = 12;
int 32-bit signed integral type int val = 12;
long 64-bit signed integral type long val1 = 12;
long val2 = 34L;
byte 8-bit unsigned integral type byte val1 = 12;
byte val2 = 34U;
ushort 16-bit unsigned integral type ushort val1 = 12;
ushort val2 = 34U;
uint 32-bit unsigned integral type uint val1 = 12;
uint val2 = 34U;
ulong 64-bit unsigned integral type ulong val1 = 12;
ulong val2 = 34U;
ulong val3 = 56L;
ulong val4 = 78UL;
float Single-precision floating point type float value = 1.23F;
double Double-precision floating point type double val1 = 1.23
double val2 = 4.56D;
bool Boolean type; a bool value is either bool value = true;
true or false
char Character type; a char value is a Unicode char value = 'h';
character
decimal Precise decimal type with 28 significant digits decimal value = 1.23M;
你也可以自定义自己的预定义类型，可以这样：
*/
using System;
struct Digit
{...}
class Test
{
static void TestInt() {
int a = 1;
int b = 2;
int c = a + b;
Console.WriteLine(c);
}
static void TestDigit() {
Digit a = (Digit) 1;
Digit b = (Digit) 2;
Digit c = a + b;
Console.WriteLine(c);
}
static void Main() {
TestInt();
TestDigit();
}
}
/*
这一节有点沉闷。：（
1.6 统一系统类型（Type system unification）
c#独创了一种类型——统一系统类型（为了这个累刑，我头疼死了。谁有更好的名字，请务必告诉我）。总之，所有的其他类型，包括值和引用，都可以被当作统一系统类型来对待。从概念上说，所有的类型都从它派生。这样，其他的类型就可以使用统一系统类型的属性和方法。包括一些“简单”类型，如：int。还是给个例子吧：
*/
using System;
class Test
{
static void Main() {
Console.WriteLine(3.ToString());
}
}
/*
“3.ToString()”调用了object的“ToString()”方法。相信学过c/c++的朋友都知道要输出一个数字有多麻烦，现在就省事了。再看一个：*/
class Test
{
static void Main() {
int i = 123;
object o = i; // boxing
int j = (int) o; // unboxing
}
}
/*
这个像帽子戏法的例子中，从“int”转换成“object”，又转换回来。这样一来，在值和引用之间就架起了一座桥梁。
这样有什么用呢。即兴举一个常见的例子...就min把。在c/c++中：*/
// c/c++ code
void min(int i, int j)
{
return ((i < j) ? i : j);
}
/* 如果比较的不是int，或者说可能是int，也可能是float、double呢？可以这样：*/
template
T min (T i, T j)
{
return ((i < j) ? i : j)
}
/* 用c#可以：*/
void swap (object a, object b)
{
return ((i < j) ? i : j);
}
/*
我想大家一定看出来第二个例子要比较一个int和一个float的话，还需要一些转换，而第三个例子就可以比较所有的变量！这个灵活度简直太大了。所以，我私以为，大家使用时一定要小心！
它在比较一个int和一个class的时候决不会报错的。呵呵，我发现我的翻译总是越跑越远，总是扣不住原文。篡改甚多，敬请原谅！
1.7 语句（Statements）
c#借用了c/c++大多数的语句方法，不过仍然有些值得注意的地方。还有些地方是有所改动的。在这里，我只提一些c#特有的东东。
1.7.10 “foreach”语句
“foreach”语句列举一个集合内的所有元素，并对这些元素执行一系列的操作。还是看看例子吧：*/
using System;
using System.Collections;
class Test
{
static void WriteList(ArrayList list) {
foreach (object o in list)
{
int i = (int) o;//如果是for语句，这里一定会报错！
Console.WriteLine(0);
Console.WriteLine(++i);
}
}
static void Main() {
ArrayList list = new ArrayList();
for (int i = 0; i < 10; i++)
list.Add(i);
WriteList(list);
}
}
/*这个例子用“foreach”扫描了整个“list”，并把“list”中所有的元素打印出来。有时候还是挺方便的。
1.7.15 安全检查开关（The checked and unchecked statements）
“checked”和“unchecked”语句用来控制数学运算和完整类型转换的检查工作。“checked”检查它作用的域中可能出现的违例，并抛出一个异常；而“unchecked”则阻止所有的检查。举个例子：*/
using System;
class Test
{
static int x = 1000000;
static int y = 1000000;
static int F() {
checked {return (x * y);} // 抛出 OverflowException
}
static int G() {
unchecked {return (x * y);} // 返回 -727379968
}
static int H() {
return x * y; // 缺省状?
}
static void Main() {
F(); //可以注销掉此行试试。
Console.WriteLine(G());
Console.WriteLine(H());
}
}
/*
在编译过程中不会有任何错误出现。因为“checked”和“unchecked”只在运行时才起作用。值得一说的是H()。它的缺省状态和编译器当前的缺省溢出检查的状态有关。但返回的结果肯定和F()或G()中的任一个相同。
再看一个例子：*/
using System;
class Test
{
const int x = 1000000;
const int y = 1000000;
static int F() {
checked {return (x * y);} // 编译器警告（Compile warning）：溢出（overflow）
}
static int G() {
unchecked {return (x * y);} // 返回 -727379968
}
static int H() {
return x * y; // 编译器警告（Compile warning）：溢出（overflow）
}
static void Main() {
Console.WriteLine(F()); //可以注销掉此行试试。
Console.WriteLine(G());
Console.WriteLine(H()); //可以注销掉此行试试。
}
}
/* 当F()和H()求值的时候，就会引起一个编译警告。而在G()中，因为有了“unchecked”，屏蔽了这个警
告。要注意的是“checked”和“unchecked”都不能对函数的返回值进行操作！比如：*/
class Test
{
static int Multiply(int x, int y) {
return x * y;
}
static int F() {
checked{ return Multiply(1000000, 1000000); } // 与 return Multiply(1000000, 1000000);
} // 有相同的效果。
}
/* 其实大家稍微想一下知道为什么m$没有这么做！对这个内容的讨论超出本文的范围和俺的能力之外哦。
在c#中，所有的十六进制数都是uint。如果用强制类型转换会引起编译器报错。用“unchecked”则可以跳过这个机制，把uint的十六进制数转化为int。如：*/
class Test
{
public const int AllBits = unchecked((int)0xFFFFFFFF);
public const int HighBit = unchecked((int)0x80000000);
}
/* 上例所有的常数都是uint，而且超过了int的范围，没有“unchecked”，这种转换会引发一个编译器错误。注意：上面用的是“unchecked”操作符。不是语句。不过它们之间除了一个用“()”，另一个用“{}”以外，几乎一样。BTW，“checked”同样。
1.7.16 “lock”语句（The lock statement）
“lock”获得一个相互排斥的对象锁定。（俺查过一些资料，但都没有清晰说明，暂不介绍）
1.8 类（Classes）
类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
· “public” 可以被所有代码访问；
· “protected” 只可以被继承类访问；
· “internal” 只可以被同一个项目的代码访问;
· “protected internal”只可以被同一个项目的代码或继承类访问；
· “private” 只可以被本类中的代码访问。
缺省状态是“private”。
1.9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100个points。在类“Point”中需要分配101个独立的对象（object）。*/
class Point
{
public int x, y;
public Point() {
x = 0;
y = 0;
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
class Test
{
static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
points[i] = new Point(i, i*i);
}
}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译了 ^_^ ）。
1.10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
interface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
interface IControl
{
void Paint();
}
interface ITextBox: IControl
{
void SetText(string text);
}
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”和“IControl”继承。
*/
interface IDataBound
{
void Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
public void Paint();
public void Bind(Binder b) {...}
}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都以“public”的身份在“EditBox”类中实现。
1.10 界面（Interfaces）
界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/
interface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
/*
例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
*/
interface IControl
{
void Paint();
}
interface ITextBox: IControl
{
void SetText(string text);
}
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”和“IControl”继承。
*/
interface IDataBound
{
void Bind(Binder b);
}
public class EditBox: Control, IControl, IDataBound
{
public void Paint();
public void Bind(Binder b) {...}
}
/*
在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都以“public”的身份在“EditBox”类中实现。
1.11 枚举（Enums）
枚举声明为一组属性相同的常量定义一个统一的类别名字。它常用于一些在编译时已知范围的常量。但这些常量的具体值要在执行时才能确定。比如，已知三原色是红蓝绿，它们同属于颜色。可以定义如下：
*/
enum Color {
Red,
Blue,
Green
}
/*
我们创建一个shape（形体）类，每一个形体都会有颜色。颜色是属于“shape”的属性。但具体的颜色就要在执行时才能决定：
*/
class Shape
{
public void Fill(Color color) {
switch(color) {
case Color.Red:
...
break;
case Color.Blue:
...
break;
case Color.Green:
...
break;
default:
break;
}
}
}
/*
这个File方法地说明了如何将一种给定的颜色赋予shape类。枚举比起普通整数常量的优胜之处在于：它使得代码更容易阅读理解和更安全。枚举的常量可以由编译器决定。使用时编译器还可以检查它的有效性。枚举其实不是c#特有的。嘿嘿，我就不详细介绍喽。趁机投篮！如果有人感兴趣——自己看书！（为了避免香蕉吃的太多就介绍本书《c语言编程常见问题解答》清华1996。29.00人民币。虽然古老，俺在书店还能见到）
1.12 名字空间（Namespaces）
我们在前面已对namespace花了不少笔墨（俺都忘了该如何接上了！O.K.请大家看完再倒）。我们曾经说“i not
like the hello world”。但是在程序中要经常说就会很累，如果要在别的代码中用就更繁了，这时可以用
namespace搭救。我把第一个例子切开，代码如下：*/
namespace MyOpinion
{
public class Message
{
public string GetMessage() {
return "i dont like Hello world";
}
}
}
/*
如果我想用namespace建立一个自己的库，就要对我的自定义函数和类进行分类，并填入相应的namespace中。
如：*/
namespace Mylib.Csharp.MyOpinion
{
public class Message
{
public string GetMessage() {
return "i dont like Hello world";
}
}
}
/*
namespace是分等级的，“Mylib.Csharp.MyOpinion”其实是缩写，每个“.”后面的namespace都被它前面的包
含。如果拆开：*/
namespace Mylib
{
namespace Csharp
{
namespace MyOpinion
{....}
}
}
/*
然后，我们就可以用自己的库了：*/
using Mylib.Csharp.MyOpinion;
class test
{
static void Main() {
Message m = new Message();
System.Console.WriteLine(m.GetMessage());
}
}
/*
不过无论我们命名如何小心都会出现重名，即命名冲突。这时可以用别名来解决，比如上面的代码可以这样：*/
using MessageSource = Mylib.Csharp.MyOpinion;
class test
{
static void Main() {
MessageSource m = new MessageSource();
System.Console.WriteLine(m.GetMessage());
}
}
1.14 属性（Properties）
关于属性就不用多说了。可能有点特别的是如何得到一个属性和设置一个属性。请诸位看下例：*/
public class Button: Control
{
private string caption;
public string Caption {
get {
return caption;
}
set {
caption = value;
Repaint();
}
}
}
/*
有了上面的定义，我们就可以对Button进行读取和设置它的Caption属性：*/
Button b = new Button();
b.Caption = "ABC"; // 设置
string s = b.Caption; // 读取
b.Caption += "DEF”; // 读取 & 设置
