第二讲 C#基础
为适应未来社会的发展，微软推出了.NET战略，以此作为下一代网络应用基础，微软的所有产品，包括操作系统、办公软件以及开发工具都将转移到.NET平台上。.NET所包含的技术全面先进，必将对今后的软件开发和应用形式产生巨大的影响。
在.NET平台上，C#是微软为了适应未来网络技术的发展而推出的新一代编程语言，它是专为.NET战略开发的编程语言。
虽然.NET平台上包含多种编程语言，并且所有语言开发出的.NET应用程序效果也是一样的，但是，C#本身作为一种编程语言，它是从著名的C++ 进化而来的，并综合了C++ 和Java的优点，是.NET主推的语言，在.NET中起着不可或缺的作用，有志于在.NET平台上开发的程序员必须了解这种语言。
第一节 C#程序结构：
我们先来做一个最简单的控制台程序，并以此作为下一步试验的基础。
using System;
namespace cs1
{
class Class1
{
//应用程序的主入口点。
[STAThread]
static void Main(string[] args)
{
}
}
}
程序结构结构：
using System;
指明本程序引用的名称空间，后面需要用到的类，都要事先using进来。
namespace 语句
定义一个“语句”名称空间，这个程序定义的所有类，都位于这个名称空间下面，一个程序可以定义多个名称空间，一个名称空间可以包含多个类。但一个类只能处于一个名称空间下面。不同名称空间下相同名字的类，被认为是完全不同的东西。
static void Main(string[] args)
{
}
这是应用程序主入口点，用作方法的返回类型时，void 关键字指定方法不返回值。在方法的参数列表中不允许使用 void。例如，采用以下形式声明一个无参数的、不返回值的方法：void MyMethod();
我们的实验程序可以写到这个方法里面，比如：
static void Main(string[] args)
{
Console.WriteLine("您好，这是我的第一个C#程序");
}
运行：
当然，后面我们也会讨论真正的Windows Form程序的写法，不过，控制台程序作为一个基础，你是必须要掌握的。
第二节 数据类型和运算符
一、 常数
在C#语言中，有布尔型常数，数值型常数和数值型常数。
2-1布尔型常数
布尔型常数只有true和false两个值，它们也是关键字。实际上在C语言中是没有这两个常数的，在那里是用0表示false，而其他非0数值表示true。但是在C#里面为了减少错误，还是加入了这两个常数，以保证语言的确定性。使用这个常数的更重要的原因，是.NET平台上不同语言布尔类型的数值并不相同，为了不同语言之间便于转换，请坚持使用true/false表示布尔类型的结果，这样利用中间语言，就可以实现不同语言之间的正确转换。
2-2数值型常数
数值型常数分为整形常数和浮点型常数。
整形常数：
十进制表示：2，100等；
十六进制表示（前面加0x）：0x10（相当于十进制16）；
这个区别要加以注意。
浮点型常数：
比如：1.25，-1.23 ，0.884， .884；
也可以用科学计数法：25e20（表示20乘以10的20次方）。
试验：
Console.WriteLine(10);
Console.WriteLine(0x10);
Console.WriteLine(1.884);
Console.WriteLine(2.4e25);
结果：
10
16
1.884
2.4E25
注意：在java里面，010表示八进制的8，但在C#中间并没有这种表示，它仍然是十进制的10，这些区别要加以注意。
字符型常数
字符型常数包括单个字符和一串字符，也可以是不可打印的字符，如下表：
|
特殊字符 |
说明 |
|
\ |
续行符，表示下一行是本行的继续 |
|
\n |
换行符 |
|
\b |
退格 |
|
\r |
回车 |
|
\f |
走纸 |
|
\t |
水平制表符 |
|
\v |
垂直制表符 |
|
\\ |
反斜线 |
|
\’ |
单引号 |
|
\’’ |
双引号 |
|
\0 |
空字符，即字符0 |
下面是一些合法的字符型常数：
‘A’，’B’，’\n’，’t’，’\\’
二、 标示符
在C#中，标示符的第一个字母必须是下列之一：大小写英文字母，下划线（_）,美元符（$），其它都是错误的。
理论上，标示符的长度不受限制，但如果给类起名子，由于类是放在文件中的，所以名字要符合所用操作系统的规范。
定义变量的方法如下：
数据类型 标示符[，标示符……];
有些数据类型的变量，可以通过下面的方法转换数据类型
（数据类型）标示符
与C语言不同，变量一旦被声明，就会给它赋于初值，不同的变量初值是不同的。
第三节 基本数据类型和运算符
3-1 布尔型
布尔型用来处理逻辑判断，两目的布尔运算符见下表：
|
操作数1 |
操作数2 |
&(AND) |
&&(AND) |
|(OR) |
||(OR) |
^(XOR) |
|
True |
true |
true |
true |
true |
True |
false |
|
True |
false |
false |
False |
true |
true |
True |
|
False |
true |
false |
False |
true |
true |
True |
|
False |
false |
false |
false |
false |
false |
false |
单目运算符
|
操作数 |
!(NOT) |
|
True |
false |
|
False |
True |
要注意，&和&& 以及 |和||是有区别的：
&、|、^是位运算符，用于对两个整数进行位运算，它们同时也可以作为逻辑运算符，这点和C语言是一样的，但这点也值得探讨，因为C语言中逻辑真和假本来就是数字（1，0），当然可以进行位运算，但在java中，true和false是不能转换成数字的，所以用于逻辑运算从道理上就有点勉强了。
另外，还要看到位运算符和逻辑运算符在运算方式上也是不同的。
我们来看两个表达式：
（1） true||false
（2） true|false
在计算（1）的时候，系统只要看到true，就会计算出结果true，后面的部分就不管了。
而在计算（2）的时候，系统的确将true（看作1）和false（看作0）作了二进制计算，得到的是计算结果。
下面看一个例子：
int a=1;
int b=2;
Boolean c=true;
Boolean d=false;
Console.WriteLine(a|b);
Console.WriteLine(c|d);
Console.WriteLine(c||d);
结果：
3
true
true
第一个结果是3的原因在于：
01
or 10
-----------
11
这恰恰是十进制的3。
而如果写Console.WriteLine(c||d);将是错误的。
3-2 字符型
在C#中规定，字符型为16位Unicode编码（C中为8位），字符型可以通过转换转成整数型或浮点型，实际上，可以把字符型变成十六位无符号整数使用，整数的值是该字符Unicode编码。
字符型变量用char关键字声明，默认值为’\0’。
下面看一个例子：
char va='a',vb='b';
Console.WriteLine(va);
Console.WriteLine(vb);
Console.WriteLine("String:"+va+vb);
Console.WriteLine(va+vb);
Console.WriteLine((int)va);
Console.WriteLine((int)vb);
Console.WriteLine(va==97);
结果应该是：
a
b
String:ab
195
97
98
true
第三行：自动转成字符串连接；
第四行：作加法运算的时候，系统自动把它转成整形数（Unicode编码），用其和输出；
第五、六行：输出的是其Unicode编码；
第八行：进一步验证了字符数据和对应的编码之间的关系。
3-3整形
下表显示了整型的大小和范围，这些类型构成了简单类型的一个子集。
类型 范围 大小
sbyte -128 到 127 有符号 8 位整数
byte 0 到 255 无符号 8 位整数
char U+0000 到 U+ffff 16 位 Unicode 字符
short -32,768 到 32,767 有符号 16 位整数
ushort 0 到 65,535 无符号 16 位整数
int -2,147,483,648 到 2,147,483,647 有符号 32 位整数
uint 0 到 4,294,967,295 无符号 32 位整数
long -9,223,372,036,854,775,808
到 9,223,372,036,854,775,807 有符号 64 位整数
ulong 0
到 18,446,744,073,709,551,615 无符号 64 位整数
备注
如果整数表示的值超出了 ulong 的范围，将产生编译错误。
整形数据可以转成字符型和浮点型，一种整数型也可以转成另一种整数型，不过要注意，当长度大的向长度小的整数型转换的时候，可能丢失精度。
比如：
int i=350000;
short j=(short)i;
Console.WriteLine(i);
Console.WriteLine(j);
结果：
350000
22320
可以对整形数据进行操作的运算符有：
|
名称 |
运算符 |
进行运算的数据类型 |
运算结果类型 |
|
关系（双目） |
<，<= ，= = ，!= ，>=， > |
整形或者浮点型 |
布尔型 |
|
正负（单目） |
+ ， - |
整形或者浮点型 |
与操作数一致 |
|
四则运算（双目） |
+，-，*，/，%（取模） |
整形或者浮点型 |
两个操作数都是整形时，结果为整形；有一个为浮点型是结果为浮点型。 |
|
增量和减量（单目） |
++ ，-- |
整形或者浮点型 |
与操作数一致 |
|
位移（双目） |
<<（左移一位），
>>（右移一位） |
整形 |
整形 |
|
位自反（单目） |
~ |
整形 |
整形 |
|
位运算（双目） |
&(AND)，|(OR)，^(XOR) |
整形 |
整形 |
当两个不同类型的操作数进行运算的时候，运算结果以较长位数的操作数为准。
下面是运算符的几个例子。
例一：
移位运算实际上是乘2或者除以2，而V 1<<V2，相当于V1*(2的V2次方)；
V 1>>V2，相当于V1/(2的V2次方)；
移位运算比实际的乘除速度要快得多。
下面的例子可以看到这个情况。
Console.WriteLine(1024<<2);
Console.WriteLine(1024>>2);
结果是
4096
256
例二：增量运算
int k=10,l=10;
Console.WriteLine(k);
Console.WriteLine(l);
k++;
l++;
Console.WriteLine(k);
Console.WriteLine(l);
结果：
10
10
11
11
例三：除数为0的错误
int izero,g;
izero=0;
g=1/izero;
结果为：
3-4 浮点型
C#有两种浮点类型：
float 32位
double 64位
类型 大致范围 精度
float ±1.5 × E-45 到 ±3.4 × E+38 7 位
double ±5.0 × E-324 到 ±1.7 × E+308 15 到 16 位
把浮点数转换成整数的时候，总是转换成接近0的那个整数。
Console.WriteLine((int)5.7);
Console.WriteLine((int)5.1);
Console.WriteLine((int)-5.7);
Console.WriteLine((int)-5.1);
结果为：
5
5
-5
-5
在使用浮点常数的时候，要注意一个问题：浮点常数总是作为double存放的，这和整数常数不同，所以，编译下面的例子就会出错：
float f;
f=3.56;
Console.WriteLine(f);
解决的办法，就是把浮点数强制转换为float类型。3.56f或者3.56F。
float f;
f=3.56F;
Console.WriteLine (f);
结果是：
3.56
货币类型：
Decimal 16 -79228162514264337593543950335 0.0000000000000000000000000001
到 到
0.0000000000000000000000000001 79228162514264337593543950335
保留四位小数。
在C#中，对声明变量是赋了初值的：
基本数据类型 初值
布尔型 false
字符型 ‘\0’
整形 0
float 0.0f
double 0.0d
3-6 运算符小结：
算术运算（二元）：
+（加）， -（减），*（乘），/（除）， %（取模，求余数）；
逻辑（布尔型和按位）：
&（与） |（或） ^（异或） !（非） ~（求反） &&（逻辑与） ||（逻辑或）
true 和 false
其中，前五个操作符（& | ^ ! ~）也可以用于位操作。
字符串串联 +
递增、递减 ++ --
对操作数进行加一和减一操作，例如： x++，x--，++x，--x
移位 << >>
把操作数（int或long）移动指定的位数，其中<<左移，>>右移。
例如：
x<<1 （左移一位，相当于乘以2 ）
x>>2 （右移两位，相当于除以4 ）
注意，当进行左移操作的时候，被移出的高位将被忽略，低位将被填上0。
当进行右移操作的时候，低位移出部分将被忽略，如果操作的是有符号数
（int或long）,则高位填上符号位，如果是无符号数，则高位将填上0。
关系（进行表达式的比较操作）
==（等于） !=（不等于） <（小于） >（大于）
<=（小于等于） >=（大于等于）
赋值
（X += 100 相当于 X=X+100 ）
=（等于） +=（加等） -=（减等） *=（乘等） /=（除等）
%=（模等） &=（与等） |=（或等） ^=（异或等）
<<=（左移等） >>=（右移等）
成员访问 .(用来访问类的成员)
索引 []
利用索引的方法访问数组、索引器或属性。
例如：
int[] arr, arr[0]=1;
转换 ()
用来进行类型转换操作
例如：
int a=(int)X 把ｘ转换成整数后赋给ａ。
条件 ?:
这是一个三元操作符，这个操作符根据表达式的值返回两个值中的一个，
例如：
int a=(x>0)?1:0
表示，如果x>0(true)则a=1，否则的话，a=0
创建对象 New
3-6 运算的优先级
算符的优先级和顺序关联性当一个表达式包含多个运算符时，这些运算符的优先级控制各运算符的计算顺序。
例如，表达式 x + y * z 按 x + (y * z) 计算，因为 * 运算符具有的优先级比 + 运算符高。运算符的优先级由运算符的关联语法产生式的定义确定。例如，一个增量表达式由以 + 或 - 运算符分隔的乘法表达式组成，因此给 + 和 - 运算符赋予的优先级比 *、/ 和 % 运算符低。
下表按照从最高到最低的优先级顺序概括了所有的运算符：
初等项 x.y f(x) a[x] x++ x-- new
typeof checked unchecked
一元 + - ! ~ ++x --x (T)x
乘法 * / %
加法 + -
移位 << >>
关系和类型检测 < > <= >= is as
相等 == !=
逻辑 AND &
逻辑 XOR ^
逻辑 OR |
条件 AND &&
条件 OR ||
条件 ?:
赋值 = *= /= %= += -= <<= >>= &= ^= |=
当操作数出现在具有相同优先级的两个运算符之间时，运算符的顺序关联性控制运算的执行顺序：
除了赋值运算符外，所有的二元运算符都向左顺序关联，意思是从左；
向右执行运算。例如，x + y + z 按 (x + y) + z 计算；
赋值运算符和条件运算符 (?:) 都向右顺序关联，意思是从右向左执；
行运算。例如，x = y = z 按 x = (y = z) 计算。
优先级和顺序关联性都可以用括号控制。例如，x + y * z 先将 y 乘以 z 然后将结果与 x 相加，而 (x + y) * z 先将 x 与 y 相加，然后再将结果乘以 z。
第四节 C#的表达式
4-1 条件选择语句
if-else
if 语句是表达式求得 true 值时执行代码块的控制语句。它的形式为：
if (expression)
statement1
[else
statement2]
此处：
expression
一个表达式，可隐式转换为 bool 或包含重载 true 和 false 运算符的类型。
statement1
expression 为 true 时执行的嵌入语句。
statement2
expression 为 false 时执行的嵌入语句。
备注
如果 expression 为 true，则执行 statement1。如果可选的 else 子句存在并且 expression 求得 false 值，则执行 statement2。执行 if 语句之后，控制传递给下一个语句。
如果 if 语句的两个结果中有任何一个结果（true 或 false）导致执行一个以上的语句，则可通过将多个语句包括在块中按条件执行它们。
在测试条件时执行的语句可以是任何种类的，包括嵌套在原始 if 语句中的另一个 if 语句。在嵌套的 if 语句中，else 子句属于没有相应 else 的最后一个 if。例如：
private void button2_Click(object sender, System.EventArgs e)
{
int x;
int y;
string z;
z=textBox1.Text;
x=20;
y=Int32.Parse(z);
if (x > 10)
if (y > 20)
textBox2.Text="这是第一个";
else
textBox2.Text="这是第二个";
}
注意：和VB.NET不同，C#中的等号是不能进行类型转换的，所以必须有下面的语句进行类型转换。
y=Int32.Parse(z);
在此例中，如果条件 (y > 20) 求得 false 值，则显示“这是第二个”。但如果要使 “这是第二个”与条件 (x >10) 关联，则使用大括号：
private void button3_Click(object sender, System.EventArgs e)
{
int x;
int y;
string z;
z=textBox1.Text;
x=8;
y=Int32.Parse(z);
if (x > 10)
{if (y > 20)
textBox2.Text="这是第一个";}
else
textBox2.Text="这是第二个";
}
在这种情况下，条件 (x > 10) 求得 false 值时将显示“这是第二个”。
例二：
第二个例子，可以体会一下“类”在这里的应用。先做一个类（可以放在最下面，也可以专门做一个类的文件）
public class IfTest
{
public System.Windows.Forms.TextBox textB;
public void Mychar(string c)
{
char s;
s=c[0];
if (Char.IsLetter(s))
textB.Text="这是字母";
else
textB.Text="这不是字母";
}
}
在Form1中，写Button事件：
private void button4_Click(object sender, System.EventArgs e)
{
IfTest Myclass;
Myclass=new IfTest();
string s;
s=textBox1.Text;
Myclass.textB=textBox2;
Myclass.Mychar(s);
}
这里，我们可以看到如何构造一个类的实例，并且通过引用传递，把类中的数据在textBox2种显示出来。
这里用到了字符类型，下面简要的说明一下：
char 类型的常数可以写成字符、十六进制换码序列或 Unicode 表示形式。您也可以显式转换整数字符代码。以下所有语句均声明了一个 char 变量并用字符 X 将其初始化：
char MyChar = 'X'; // Character literal
char MyChar = '\x0058'; // Hexadecimal
char MyChar = (char)88; // Cast from integral type
char MyChar = '\u0058'; // Unicode
转换
char 类型可隐式转换为 ushort、int、uint、long、ulong、float、double 或 decimal 类型。但是，不存在从其他类型到 char 类型的隐式转换。
关于New的问题，后面我们还会进一步讨论。
还可以扩展 if 语句，使用下列 else-if 排列来处理多个条件：
if (Condition_1)
Statement_1;
else if (Condition_2)
Statement_2;
else if (Condition_3)
Statement_3;
...
else
Statement_n;
示例
此例检查输入字符是否是小写字符、大写字符或数字。否则，输入字符不是字母字符。程序利用 else-if 阶梯。
下面再做一个类：
public class IfTest2
{
public System.Windows.Forms.TextBox textB;
public void Mychar(string c)
{
char s;
s=c[0];
if (Char.IsUpper(s))
textB.Text="这是大写字母";
else if (Char.IsLower(s))
textB.Text="这是小写字母";
else if (Char.IsDigit(s))
textB.Text="这是数字";
else
textB.Text="这不是字母或者数字";
}
}
只要把类的声明语句稍稍改一下，就可以使用这个类的方法：
private void button4_Click(object sender, System.EventArgs e)
{
IfTest2 Myclass;
Myclass=new IfTest2();
string s;
s=textBox1.Text;
Myclass.textB=textBox2;
Myclass.Mychar(s);
}
4-2 switch-case语句
switch 语句是一个控制语句，它通过将控制传递给其体内的一个 case 语句来处理多个选择。switch 语句的形式为：
switch (expression)
{
case constant-expression:
statement
jump-statement
[default:
statement
jump-statement]
}
此处：
expression
一个整型或字符串型表达式。
statement
控制传递给 case 或 default 时执行的嵌入语句。
jump-statement
将控制传递到 case 体外部的跳转语句。
constant-expression
根据此表达式的值将控制传递给特定的 case。
备注
控制传递给 constant-expression 与 expression 匹配的 case 语句。switch 语句可以包含任意数量的 case 实例，但同一 switch 语句中的两个case 常数不能具有相同的值。语句体从选定的语句开始执行，一直执行到 jump-statement 将控制传递到 case 体之外为止。
请注意，每个块（包括最后一个块，不管它是 case 语句还是 default 语句）后都要有 jump-statement。与 C++ switch 语句不同，C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用 goto 一个 switch-case 或 goto default。
如果 expression 不匹配任何 constant-expression，则控制传递给可选的 default 标签后面的 statement。如果没有 default 标签，则控制传递到 switch 之外。
类：
public class CaseTest
{
public System.Windows.Forms.TextBox textB;
public void MyCase(string s)
{
textB.Clear();
int n = int.Parse(s);
int cost = 0;
switch(n)
{
case 1:
cost += 25;
//break 语句终止它所在的最近的封闭循环或条件语句。
//控制传递给终止语句后面的语句（如果有的话）
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
textB.Text="错误的选择，请输入 1, 2, or 3.";
break;
}
if (cost != 0)
textB.AppendText(cost.ToString());
}
}
事件程序：
private void button1_Click(object sender, System.EventArgs e)
{
CaseTest Myclass;
Myclass=new CaseTest();
string s;
s=textBox1.Text;
Myclass.textB=textBox2;
Myclass.MyCase(s);
}
4-3 for循环
for 循环重复执行一个语句或一个语句块，直到指定的表达式求得 false 值为止。它的形式为：
for ([initializers]; [expression]; [iterators]) statement
此处：
initializers
初始化循环计数器的表达式或赋值语句的逗号分隔列表。
expression
一个表达式，可隐式转换为 bool 或包含重载 true 和 false 运算符的类型。此表达式用于测试循环终止条件。
iterators
递增或递减循环计数器的表达式语句。
statement
要执行的嵌入语句。
备注
for 语句按下列方式重复执行 statement：
首先，计算 initializers。
然后，当 expression 求得 true 值时，执行 statement 并计算 iterators。 当 expression 求得 false 值时，控制传递到循环之外。
由于 expression 的测试发生在循环的执行之前，因此 for 语句执行零次或更多次。
for 语句的所有表达式都是可选的；例如，下列语句用于写一个无限循环：
for (;;) {
...
}
示例
private void button2_Click(object sender, System.EventArgs e)
{
textBox2.Text="";
for (int i = 1; i <= 5; i++)
textBox2.AppendText(i.ToString()+"\r\n");
//"\r\n"为转意字符
//\r回车
//\n换行
//\b退格
//\f换页
//\'单引号
//\"双引号
}
4-4 foreach, in语句
foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容以避免产生不可预知的副作用。此语句的形式如下：
foreach (type identifier in expression) statement
此处：
type
identifier 的类型。
identifier
表示集合元素的迭代变量。
expression
对象集合或数组表达式。集合元素的类型必须可以转换为 identifier 类型。
statement
要执行的嵌入语句。
备注
嵌入语句为数组或集合中的每个元素继续执行。当为集合中的所有元素，完成迭代后，控制传递给 foreach 块之后的下一个语句。
示例
此例搜索一个整数数组中的偶数和奇数。每类数字的计数器存储该类数字出现的次数。
private void button3_Click(object sender, System.EventArgs e)
{
int odd = 0, even = 0;
int[] arr = new int [] {0,1,2,5,7,8,11};
foreach (int i in arr)
{
///模数运算符 (%) 计算第二个操作数除第一个操作数后的余数。
if (i%2 == 0)
even++;
else
odd++;
}
textBox2.Text="";
for (int i = 0; i <= 6; i++)
textBox2.AppendText(arr[i].ToString()+" ");
textBox2.AppendText("\r\n");
textBox2.AppendText("偶数："+even.ToString()+"\r\n");
textBox2.AppendText("奇数："+odd.ToString()+"\r\n");
}
4-5 while循环
while 语句执行一个语句或一个语句块，直到指定的表达式求得 false 值为止。它的形式为：
while (expression) statement
此处：
expression
一个表达式，可隐式转换为 bool 或包含重载 true 和 false 运算符的类型。此表达式用于测试循环终止条件。
statement
要执行的嵌入语句。
备注
由于 expression 的测试发生在循环的执行之前，因此 while 循环执行零次或更多次。
当 break、goto、return 或 throw 语句将控制传递到循环之外时可以终止 while 循环。若要将控制传递给下一个迭代但不退出循环，请使用 continue 语句。
示例：
private void button4_Click(object sender, System.EventArgs e)
{
int n = 1;
textBox2.Text="";
while (n < 6)
{
textBox2.AppendText("循环次数 "+n.ToString()+"\r\n");
n++;
}
}
4-6 do循环
do 语句重复执行一个语句或一个语句块，直到指定的表达式求得 false 值为止。它的形式为：
do statement while (expression);
此处：
expression
一个表达式，可隐式转换为 bool 或包含重载 true 和 false 运算符的类型。此表达式用于测试循环终止条件。
statement
要执行的嵌入语句。
备注
与 while 语句不同，do 语句的体循环至少执行一次，与 expression 的值无关。
示例，注意在第二个例子中，虽然条件求得 false 值，但循环将执行一次。
private void button5_Click(object sender, System.EventArgs e)
{
int x;
int y = 0;
textBox2.Text="";
do
{
x = y++;
textBox2.AppendText("循环次数 "+x.ToString()+"\r\n");
}
while(y < 5);
textBox2.AppendText("第二个例子： "+"\r\n");
int n = 10;
do
{
textBox2.AppendText("n的数字 "+n.ToString()+"\r\n");
n++;
} while (n < 6);
}
4-7 调转语句
break 语句终止它所在的最近的封闭循环或条件语句。控制传递给终止语句后面的语句（如果有的话）。break 语句的形式为：
break;
示例
在此例中，条件语句包含一个可以从 1 计数到 100 的计数器；但 break 语句在计数达到 4 后终止循环。
// statements_break.cs
using System;
class BreakTest
{
public static void Main()
{
for (int i = 1; i <= 100; i++)
{
if (i == 5)
break;
Console.WriteLine(i);
}
}
}
输出
1
2
3
4
示例
此例在 switch 语句中演示了 break 的用法。
// statements_break2.cs
// break and switch
using System;
class Switch
{
public static void Main()
{
Console.Write("Enter your selection (1, 2, or 3): ");
string s = Console.ReadLine();
int n = Int32.Parse(s);
switch(n)
{
case 1:
Console.WriteLine("Current value is {0}", 1);
break;
case 2:
Console.WriteLine("Current value is {0}", 2);
break;
case 3:
Console.WriteLine("Current value is {0}", 3);
break;
default:
Console.WriteLine("Sorry, invalid selection.");
break;
}
}
}
输入
1
示例输出
Enter your selection (1, 2, or 3): 1
Current value is 1
如果输入了 4，则输出为：
Enter your selection (1, 2, or 3): 4
Sorry, invalid selection.
注意一下，C#里面break的用法和java并不一样。
第五节 方法调用语句
1） ref参数声明方式
方法参数上的 ref 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
若要使用 ref 参数，必须将参数作为 ref 参数显式传递到方法。ref 参数的值被传递到 ref 参数。
传递到 ref 参数的参数必须最先初始化。将此方法与 out 参数相比，后者的参数在传递到 out 参数之前不必显式初始化。
如果两个方法的声明只在 ref 的使用方面不同，则会发生重载。
属性不是变量，不能作为 ref 参数传递。
实例：
public static void TestRef(ref char i)
{
i = 'b';
}
public static void TestNoRef(char i)
{
i = 'c';
}
private void button1_Click(object sender, System.EventArgs e)
{
char i = 'a';
TestRef(ref i);
textBox1.Text=i.ToString();
TestNoRef(i);
textBox2.Text=i.ToString();
}
}
2）out参数声明方式
方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。
若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。
如果两个方法的声明仅在 out 的使用方面不同，则会发生重载。
属性不是变量，不能作为 out 参数传递。
有关传递数组的信息，请参阅使用 ref 和 out 传递数组。
示例
public static int TestOut(out char i)
{
i = 'b';
return -1;
}
private void button2_Click(object sender, System.EventArgs e)
{
char i;
textBox1.Text=TestOut(out i).ToString();
textBox2.Text=i.ToString();
}
3）params参数声明方式：
params 关键字可以指定在参数数目可变处采用参数的方法参数。
在方法声明中的 params 关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params 关键字。
示例
void Useparams(params int[] list)
{
listBox1.Items.Clear();
for (int i=0;i<list.Length;i++)
{
listBox1.Items.Add(list[i].ToString());
}
}
void Useparams2(params object[] list)
{
listBox1.Items.Clear();
for (int i=0;i<list.Length;i++)
{
listBox1.Items.Add((object)list[i].ToString());
}
}
//传递一个参数
private void button1_Click(object sender, System.EventArgs e)
{
Useparams(1);
}
//传递三个参数
private void button2_Click(object sender, System.EventArgs e)
{
Useparams(1,2,3);
}
//传递不同类型的参数
private void button3_Click(object sender, System.EventArgs e)
{
Useparams2(1,'a',"test");
}
//传递数组
private void button4_Click(object sender, System.EventArgs e)
{
int[] myarray=new int[3]{10,20,30};
Useparams(myarray);
}
4）new 关键字
在 C# 中，new 关键字可用作运算符或修饰符。
new 运算符 用于在堆上创建对象和调用构造函数。
new 修饰符 用于隐藏基类成员的继承成员。
a>new 运算符
new 运算符用于创建对象和调用构造函数，例如：
Class1 MyClass = new Class1();
也用于为值类型调用默认的构造函数，例如：
int myInt = new int();
在上一个语句中，myInt 初始化为 0，它是 int 类型的默认值。该语句的效果等同于：
int myInt = 0;
有关默认值的完整列表，请参阅默认值表。
记住，为结构声明默认的构造函数是一个错误，因为每一种值类型都隐式具有一个公共的默认构造函数。但是，可以在结构类型上声明参数化的构造函数。
值类型对象（例如结构）是在堆栈上创建的，而引用类型对象（例如类）是在堆上创建的。
不能重载 new 运算符。
第六节 数组
7-1 一维数组
可以如下例所示声明一个由 5 个整数组成的数组：
int[] myArray = new int [5];
此数组包含从 myArray[0] 到 myArray[4] 的元素。new 运算符用于创建数组并将数组元素初始化为它们的默认值。在此例中，所有数组元素都初始化为零。
可以用相同的方式声明存储字符串元素的数组。例如：
string[] myStringArray = new string[6];
数组初始化
可以在声明数组时将其初始化，在这种情况下不需要级别说明符，因为级别说明符已经由初始化列表中的元素数提供。例如：
int[] myArray = new int[] {1, 3, 5, 7, 9};
可以用相同的方式初始化字符串数组。下面声明一个字符串数组，其中每个数组元素用每天的名称初始化：
string[] weekDays = new string[]
{"Sun","Sat","Mon","Tue","Wed","Thu","Fri"};
如果在声明数组时将其初始化，则可以使用下列快捷方式：
int[] myArray = {1, 3, 5, 7, 9};
string[] weekDays = {"Sun","Sat","Mon","Tue","Wed","Thu","Fri"};
可以声明一个数组变量但不将其初始化，但在将数组分配给此变量时必须使用 new 运算符。例如：
int[] myArray;
myArray = new int[] {1, 3, 5, 7, 9}; // OK
myArray = {1, 3, 5, 7, 9}; // Error
值类型数组和引用类型数组
请看下列数组声明：
MyType[] myArray = new MyType[10];
该语句的结果取决于 MyType 是值类型还是引用类型。如果是值类型，则该语句将创建一个由 10 个 MyType 类型的实例组成的数组。如果 MyType 是引用类型，则该语句将创建一个由 10 个元素组成的数组，其中每个元素都初始化为空引用。
将数组作为参数传递
可以将初始化的数组传递给方法。例如：
PrintArray(myArray);
也可以在一个步骤中初始化并传递新数组。例如：
PrintArray(new int[] {1, 3, 5, 7, 9});
示例
在下例中，初始化一个字符串数组并将其作为参数传递给 PrintArray 方法（该数组的元素显示在此方法中）：
// cs_sd_arrays.cs
using System;
public class ArrayClass
{
static void PrintArray(string[] w)
{
for (int i = 0 ; i < w.Length ; i++)
Console.Write(w[i] + "{0}", i < w.Length - 1 ? " " : "");
Console.WriteLine();
}
public static void Main()
{
// Declare and initialize an array:
string[] WeekDays = new string []
{"Sun","Sat","Mon","Tue","Wed","Thu","Fri"};
// Pass the array as a parameter:
PrintArray(WeekDays);
}
}
输出
Sun Sat Mon Tue Wed Thu Fri
7-2 多维数组
数组可以具有多个维度。例如，下列声明创建一个四行两列的二维数组：
int[,] myArray = new int[4,2];
另外，下列声明创建一个三维（4、2 和 3）数组：
int[,,] myArray = new int [4,2,3];
数组初始化
可以在声明数组时将其初始化，如下例所示：
int[,] myArray = new int[,] {{1,2}, {3,4}, {5,6}, {7,8}};
也可以初始化数组但不指定级别：
int[,] myArray = {{1,2}, {3,4}, {5,6}, {7,8}};
如果要声明一个数组变量但不将其初始化，必须使用 new 运算符将数组分配给此变量。例如：
int[,] myArray;
myArray = new int[,] {{1,2}, {3,4}, {5,6}, {7,8}}; // OK
myArray = {{1,2}, {3,4}, {5,6}, {7,8}}; // Error
也可以给数组元素赋值，例如：
myArray[2,1] = 25;
将数组作为参数传递
可以将初始化的数组传递给方法。例如：
PrintArray(myArray);
也可以在一个步骤中初始化并传递新数组。例如：
PrintArray(new int[,] {{1,2}, {3,4}, {5,6}, {7,8}});
示例
在此例中，初始化一个二维数组并将其传递给 PrintArray 方法（该数组的元素显示在此方法中）。
// cs_td_arrays.cs
using System;
public class ArrayClass
{
static void PrintArray(int[,] w)
{
// Display the array elements:
for (int i=0; i < 4; i++)
for (int j=0; j < 2; j++)
Console.WriteLine("Element({0},{1})={2}", i, j, w[i,j]);
}
public static void Main()
{
// Pass the array as a parameter:
PrintArray(new int[,] {{1,2}, {3,4}, {5,6}, {7,8}});
}
}
输出
Element(0,0)=1
Element(0,1)=2
Element(1,0)=3
Element(1,1)=4
Element(2,0)=5
Element(2,1)=6
Element(3,0)=7
Element(3,1)=8
7-3 交错数组
交错数组是元素为数组的数组。交错数组元素的维度和大小可以不同。交错数组有时称为“数组的数组”。本主题包含声明、初始化和访问交错数组的示例。
下面声明一个由三个元素组成的一维数组，其中每个元素都是一个一维整数数组：
int[][] myJaggedArray = new int[3][];
必须初始化 myJaggedArray 的元素后才可以使用它。可以如下例所示初始化元素：
myJaggedArray[0] = new int[5];
myJaggedArray[1] = new int[4];
myJaggedArray[2] = new int[2];
每个元素都是一个一维整数数组。第一个元素是由 5 个整数组成的数组，第二个是由 4 个整数组成的数组，而第三个是由 2 个整数组成的数组。
也可以使用初始值设定项用值填充数组元素，在这种情况下不需要数组大小，例如：
myJaggedArray[0] = new int[] {1,3,5,7,9};
myJaggedArray[1] = new int[] {0,2,4,6};
myJaggedArray[2] = new int[] {11,22};
还可以在声明数组时将其初始化，如：
int[][] myJaggedArray = new int [][]
{
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
可以使用下列快捷方式（注意在元素初始化中不能省略 new 运算符，因为元素没有默认初始化）：
int[][] myJaggedArray = {
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
};
可以如下例所示访问个别数组元素：
// Assign 33 to the second element of the first array:
myJaggedArray[0][1] = 33;
// Assign 44 to the second element of the third array:
myJaggedArray[2][1] = 44;
可以混合使用交错数组和多维数组。下面声明和初始化一个一维交错数组，该数组包含大小不同的二维数组元素：
int[][,] myJaggedArray = new int [3][,]
{
new int[,] { {1,3}, {5,7} },
new int[,] { {0,2}, {4,6}, {8,10} },
new int[,] { {11,22}, {99,88}, {0,9} }
};
可以如下例所示访问个别元素，该示例显示第一个数组的元素 [1,0] 的值（值为 5）：
Console.Write("{0}", myJaggedArray[0][1,0]);
示例
下例生成数组 myArray，而此数组的元素为数组。每一个数组元素都有不同的大小。
// cs_array_of_arrays.cs
using System;
public class ArrayTest
{
public static void Main()
{
// Declare the array of two elements:
int[][] myArray = new int[2][];
// Initialize the elements:
myArray[0] = new int[5] {1,3,5,7,9};
myArray[1] = new int[4] {2,4,6,8};
// Display the array elements:
for (int i=0; i < myArray.Length; i++)
{
Console.Write("Element({0}): ", i);
for (int j = 0 ; j < myArray[i].Length ; j++)
Console.Write("{0}{1}", myArray[i][j],
j == (myArray[i].Length-1) ? "" : " ");
Console.WriteLine();
}
}
}
输出
Element(0): 1 3 5 7 9
Element(1): 2 4 6 8
7-4 使用 ref 和 out 传递数组
与所有的 out 参数一样，在使用数组类型的 out 参数前必须先为其赋值，即必须由接受方为其赋值。例如：
public static void MyMethod(out int[] arr)
{
arr = new int[10]; // definite assignment of arr
}
与所有的 ref 参数一样，数组类型的 ref 参数必须由调用方明确赋值。因此不需要由接受方明确赋值。可以将数组类型的 ref 参数更改为调用的结果。例如，可以为数组赋以 null 值，或将其初始化为另一个数组。例如：
public static void MyMethod(ref int[] arr)
{
arr = new int[10]; // arr initialized to a different array
}
下面的两个示例说明 out 和 ref 在将数组传递给方法上的用法差异。
示例 1
在此例中，在调用方（Main 方法）中声明数组 myArray，并在 FillArray1 方法中初始化此数组。然后将数组元素返回调用方并显示。
public void FillArray1(out int[] myArray)
{
// 初始化数组:
myArray = new int[5] {1, 2, 3, 4, 5};
}
//out
private void button1_Click(object sender, System.EventArgs e)
{
int[] myArray; //定义数组
//调用FillArray1并out数组，事先没有初始化
FillArray1(out myArray);
//显示
listBox1.Items.Clear();
for (int i=0; i < myArray.Length; i++)
listBox1.Items.Add(myArray[i].ToString());
}
输出
1
2
3
4
5
示例 2
在此例中，在调用方中初始化数组 myArray，并通过使用 ref 参数将其传递给 FillArray2 方法。在 FillArray2 方法中更新某些数组元素。然后将数组元素返回调用方并显示。
public static void FillArray2(ref int[] arr)
{
// 如果传递进来的数组初始化为null，则建立一个10个单元空数组:
if (arr == null)
arr = new int[10];
//填入数组数据:
arr[0] = 123;
arr[4] = 1024;
}
//ref
private void button2_Click(object sender, System.EventArgs e)
{
//初始化:
int[] myArray = {1,2,3,4,5};
//int[] myArray = null;
// ref调用:
FillArray2(ref myArray);
// 显示数组数据:
listBox1.Items.Clear();
for (int i = 0; i < myArray.Length; i++)
listBox1.Items.Add(myArray[i].ToString());
}
输出
123
2
3
4
1024
如果初始化改为：
int[] myArray = null;
则结果为
想想为什么呢？
7-5 数组的排序和查找
微软公司经过多年摸索，在.NET平台上大大改进了数组的性能，现在，数组可以排序、搜索元素等，过去编程人员需要花费大量时间进行数组运算的编程，现在可能轻而易举就解决了。
除数组以外，还有大量的集合类型，放在名称空间的System.Collections中，其中提供的一些类诸如ArrayList、Hashtable都有十分良好的性能。
下面分别进行讨论.
a>数组排序
数组排序主要是针对一维数组，下面是实现排序的实例：
int[] MyArray1= {3, 6, 1, 0, 5, 7, 8, 2, 9, 4};
listBox1.Items.Clear();
System.Array.Sort(MyArray1);
for (int i=0;i<10;i++)
{
listBox1.Items.Add(MyArray1[i]);
}
有时候可以利用另一个数组的值来排序第一个数组，下面的例子是利用
MyArray2的值来排序MyArray1。
int[] MyArray1= {3, 6, 1, 0, 5, 7, 8, 2, 9, 4};
int[] MyArray2= {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
listBox1.Items.Clear();
System.Array.Sort(MyArray2,MyArray1);
for (int i=0;i<10;i++)
{
listBox1.Items.Add(MyArray1[i]);
这个方法的一个实际的例子，是使一个数组按照字符的多少来排序，请看下面的例子：
string[] MyArray1= {"aa", "cccccc", "vvvv", "s"};
int[] MyArray2=new int[4];
listBox1.Items.Clear();
for (int i=0;i<4;i++)
{
MyArray2[i] = MyArray1[i].Length;
}
System.Array.Sort(MyArray2, MyArray1);
for (int i=0;i<4;i++)
{
listBox1.Items.Add(MyArray1[i]);
}
b>数组查找
下面的例子可以理解在树组中如何查找匹配的内容，给出的是数组的索引值。
使用IndexOf查找不需要数组排序：
string[] MyArray1= {"aa", "cccccc", "vvvv", "s"};
int[] MyArray2= {3, 6, 1, 0, 5, 7, 8, 2, 9, 4};
listBox1.Items.Clear();
listBox1.Items.Add(System.Array.IndexOf(MyArray1, "vvvv"));
listBox1.Items.Add(System.Array.IndexOf(MyArray2, 5));
使用BinarySearch可以在已经排序的数组中快速查找。
System.Array.Sort(MyArray1);
for(int i=0;i<4;i++)
{
listBox1.Items.Add(MyArray1[i]);
}
listBox1.Items.Add(System.Array.BinarySearch(MyArray1, "s"));
结果：
|
本类阅读TOP10