C#测试试题

第一篇：C#测试试题

一、选择题（50题/2分）

1、C#的数据类型分为（）

A、值类型

B、引用类型

C、接口类型

D、类类型

引用类型：数组类型

类类型

接口类型

2、下面C#中关于命名空间说法错误的是（B）A、命名空间用于组织相关的类型 B、命名空间可以嵌套 C、在同一个引用程序章，不同的命名空间中不允许有相同名称的类 D、use用于引用命名空间

3、关于下面程序，说法正确的是（）

btye

a=3 , c=5;btye d=a+c;Console.WriteLine(“ d=”+d);A、编译通过，结果为8 B、编译通过，结果为35 C、编译不通过“byte

a=3 , c=5;”，有错误，不能这样定义变量 D、编译不通过“btye d=a+c”有错误，d应该为int类型

注：所有的小数默认是double类型，所有的整数默认是int类型

4、关于下面程序执行并运行的结果是（）

int

x=3;int

y=5;int

res=x+(x++)+(++x)+y;Console.WriteLine(res);

A、16

B、19

C、15

D、17 ++在前，先自加，在运算 ++在后，先运算，后自加、已知程序如下

Int a=3, b=4，c=8;If(a+b>c)If(++a==b){ Console.WriteLine（++a）； } else { Console.WriteLine(a++);} 程序编译并运行，结果为（）

A、5

B、4

C

5、编译错误

D、编译通过，没有任何输出

如果if中代码块只有一条语句，那么可以省略大括号。、已知程序如下： Int

i=1, sum=0;While(i<=100){ Sum+=i;i++;} Console.WriteLine(sum);结果是（）

A、5000

C、0

D、1、5050 …100 6 B

7、请选择正确的语句（）

A、for(int i=0;intj=0;j!=10;i++;j++)B、for(int i=0;j=0;

j=i=10;i++;

j++)C、for(int i=0;j=0;j!=10;

i++;

j++)D、for(int

i=0;

intj=0;

j==i==10;

i++;

j++)

8、C# 获取数组的长度使用（）方法；

A、.lengh

B、.length()

C、Length

D、Length()

9、在C#中，定义方法的语法正确的是（）A、public

int Sum（int

x, int y）{ Return x+y;} B、public

bool Sum（int y）{ Return x+y;} C、public

int Sum（bool y）{ Return x+y;}

x, int x, int

D、public

int（int

x, int

y）{ Return x+y;}

10、在C#中下面关于循环，下面说法错误的是（）。

A.while循环和for循环都是是先判断条件表达式是否成立，若是成立，则执行循环体；否则结束循环。

B.do-while循环在Java和C#中只有大括号换行及条件表达式不同，语法和执行顺序基本一样。

C.for循环有时候可以使用整型变量做循环计算器，通过表达式限定计算器变量值控制循环。

D.foreach()自动遍历给定集合的所有值。

11、C#中分割字符串的方法是（）

A、Split

B、Length

C、Insert

D、Copy

12、在C#中，下面关于引用传递说法正确的是（）。

A、引用传递不用加ref关键字 B、使用引用传递值不会发生改变 C、使用引用传递值会发生改变 D、引用类型和值传递结果一样

13、在C#中下面关于break和continue语句的使用说法正确的是（）。A.continue语句的作用是退出当前的循环结构，而break语句是跳出本次循环，开始执行下一次循环。

B.break语句和continue语句在当前循环结构中跳转的位置基本相同。

C.在嵌套循环中，当break和continue出现在内层循环时，可能会影响外层循环的执行。

D.上面说法全部错误。

14、C#中的if 的条件是（）类型的

A、bool类型

B、int类型

C、string类型

D、引用类型

15、下列说法正确的是（）；

A、在C#中++的用法和Java中的一样 B、在C#中++在前，是先运算在加1 C、在C#中++在后，是先加1再运算 D、以上说法都是正确的

16、下列说法错误的是（）

A、C#中的数据类型可分为值类型和引用

B、C#中bool类型的默认值是false C、C#中变量的命名可以使用数字开头 D、C#中紧跟在switch结构后面表达式的值或变量是字符类型和string类型

17、使用Substring()方法从字符串administrator中截取str字符串，那么方法的两个参数应该分别为（）。

A.7 3

B.6 3

C.7 9

D.6 8

18、C#的源文件的后缀名是（）

A、.Java

B、.cs

C、.txt

D、.mdf

19、Ｃ＃中常量的声明使用（）

A、final

B、const

C、static

D、args 20、C#中对数组的初始化正确的是（）

A、int [] array={2,3,6,9,4};B、int [] arrays=new int[3]{1,6,9};C、int [] arr=new int[ ]{1,6,9};D、int [] arrays=new [2] char{1,6,9}

21、下面是一个关于转义字符使用的控制台应用程序：

static void Main(string[] args){ String str = “大家” + 'u0022' + “好” + ''';Console.WriteLine(str);Console.ReadLine();} 程序运行后，其输出结果应该为（）。

.A．大家好

.B．“大家好”.C．大家“好’.D．‘大家好’

22、下列用于折叠代码的方法为（）。.A．/.B．/* */.C．///

.D．#region #endregion

23、仔细查看下面的这段代码： static void Main(string[] args){ int i= 0;int j = 0;while(i < 3){ i++;if(i > 2){ break;} ++j;} Console.WriteLine(i);Console.WriteLine(j);} 程序运行后，其输出结果应该为（）。

.A．3,3.B．2,3.C．3,2.D．2,2

24、while语句和do-while语句的主要区别是（）。

.A．do-while的循环体至少无条件执行一次

.B．do-while允许从外部跳到循环体内

.C．while的循环体至少执行一次

.D．while的循环控制条件比do-while的严格

25、下列有关break语句的描述中，正确的是（）。.A．循环体内的break语句用于结束本次循环

.B．循环体内的break语句用于跳出循环

.C．在循环体内，break语句可以被执行多次

.D．当嵌套循环时，break语句可以退出最外层循环

26、下列哪个不可用作转义字符前缀（）。

.A．Unicode字符

.B．十六进制

.C．十进制

.D．八进制

27、已知x为字符变量，则下列赋值语句中，执行结果与其他3个不同的是（）。

.A．x=’a’;.B．x=’u0061’;.C．x=(char)97;.D．x=’x0097’;

28、已知int[][] arr=new int [3][]{new int[3]{5,6,2},new int[5]{6,9,7,8,3},new int[2]{3,2}};则arr[2][2]的值是（）。

.A．9.B．1.C．6.D．越界

29、以下的数组声明语句中，正确的是（）。.A．int a[3];.B．int [3] a;

.C．int[][] a=new int[][];.D．int [] a={1,2,3};30、可以用来遍历数组或集合中所有元素的循环是（）。

.A．while.B．do…while.C．foreach.D．If

31、下列关于数组的初始化不正确的是（）。

.A．int []a =new int[2].B．int []a =new int [2]{1,2}.C．int []a={1,3}.D．int[]a;a={1,2}

32、一个美国学者提出了一种用方框图来代替传统的程序流程图，该图符合结构化程序设计原则，通常也把这种图称为（）。

.A．结构图

.B．数据流图

.C．N-S图

.D．PAD图

33、以下算法的输出结果为（）。public static int Max(int x, int y){ if(x > y)return x;else return y;} static void Main(string[] args){ int i = 3, j = 6;int z = Max(i, j);

Console.WriteLine(“{0}”, z);}.A．3.B．6.C．程序出错

.D．9

34、关于算法不正确的是（）。

.A．算法是指为解决某一个问题而采取的步骤和方法的描述

.B．算法必须有开始和结束，并且必须保证算法规定的每一个步骤最终都能够被完成

.C．算法的每一个步骤都是严格规定好的，不能产生歧义

.D．算法可以有0个输出

35、下面关于类和对象的说法中，不正确的是（）。

.A．类是一种系统提供的数据类型

.B．对象是类的实例

.C．类和对象的关系是抽象和具体的关系

.D．任何对象只能属于一个具体的类

36、某工程有甲乙丙三人合作完成，过程如下：甲乙两人用6天时间完成工程的1/3，乙丙两人用两天完成剩余工程的1/4，甲乙丙三人用5天时间完成剩余工程。如果总收入为1800元，则乙应该分得多少？（）

.A．330元

.B．910元

.C．560元

.D．980元

37、计算1+2+3+4+5…+100，结果是（）

.A．4900.B．5000.C．5050.D．5150

38、一个家庭有两个小孩，其中有一个是女孩，问另一个也是女孩的概率（假定生男生女的概率一样）().A.1/2.B.1/4.C.3/4.D.3/8

39、您在前一家公司的离职原因是什么？（）.A．避免把“离职原因”说得太详细、太具体；

.B．不能掺杂主观的负面感受，如“太幸苦”、“人际关系复杂”、“管理太混乱”、“公司不重视人才”、“公司排斥我们某某的员工”等；

.C．回答时不要躲闪、回避，如“想换换环境”、“个人原因”等；

.D．不能涉及自己负面的人格特征，如不诚实、懒惰、缺乏责任感、不随和等；

40、下面哪个单词的中文意义是'客户，客户机'（）.A.wizard.B.file attributes.C.Destination Folder.D.Client

41、下面哪个单词的中文意义是'发布'（）.A.release.B.RIP

.C.file attributes.D.toggle break point

42、下面哪个单词的中文意义是'图形用户界面'（）

.A.DBMS

.B.graphics library.C.debug.D.GUI

43、已知程序如下：

Int a=3,b=4,c=8;If(a+b>c)If(++a==b){

Console.WriteLine(++a);

}else{

Console.WriteLine(a++);

} 程序编译并运行，结果为（）

A、5

B、4 C、编译错误

D、编译通过，没有任何输出

44、以下代码可以正常编译的是（）（多选）A、int i=1;double d=1.0;if(d==i){ Console.WriteLine(“d=i”);}

B、int i=1;int j=2;if(i=1&&j=2){ Console.WriteLine(“i=

1、j=2”);}

C、boolean b1=false;boolean b2=true;if(b1==b2){ Console.WriteLine“b1==b2”);} D、int i=1;if(i){ Console.WriteLine(“1==1”);}

45、关于while和do-while循环，下列说法错误的是（）A、两种循环除了格式不通过，功能完全相同

B、与do-while语句不同的是，while语句的循环至少执行一次

C、do-while语句首先计算终止条件，当条件满足时，才去执行循环体中的语句 D、以上都不对

46、已知下面程序： Int x=0;————； do { } While(x++

在下划线中插入哪个语句，则程序输出24（B）

A、int y=22;B、int y=23;C、int y=24;D、int y=25;

47、已知程序如下： int x=5;Console.WriteLine(++x);{ int x=7;Console.WriteLine(x);} 程序编译并运行的结果为（）A、编译通过，输出5和7 B、编译通过，输出6和7 C、编译通过，输出7和8 D、编译错误，因为x已经在main（）方法中定义过

48、下列程序输出结果为（）Int a=0;Outer;for(int i=0;i<2;i++){ for(int j=0;j<2;j++){ if(j>i){ Continue outer;} a++;} } Console.WriteLine(a);A、0 B、2 C、3 D、4

49、引用类型的数据类型字段的缺省值为（）A、0.0 B、0 C、null D、false 50、你觉得你个性上最大的优点是什么？（）A、沉着冷静、条理清楚 B、立场坚定、顽强向上

C、乐于助人和关心他人、适应能力和幽默感

D、乐观和友爱

第二篇：C#总结

引用类型是类型安全的指针，它们的内存是分配在堆（保存指针地址）上的。String、数组、类、接口和委托都是引用类型。

强制类型转换与as类型转换的区别：当类型转换非法时，强制类型转换将抛出一System.InvalidCastException异常，而as不会抛出异常，它返回一个null值。用using创建别名：using console = System.Console;访问限定符：

public 该成员可以被其他任何类访问 protected 该成员只能被其派生类访问

private 该成员只能被本类的其他成员访问 internal 该成员只能在当前编译单元的其他成员访问 带参数列表和返回值的Main方法： class Test {

public static int Main(string[] args)

{

foreach(string arg in args)

{

...}

} } 构造函数（constructor）包括实例构造函数和静态构造函数。构造函数与类名相同，且不能有返回值。例：

class TestClass {

TestClass()//实例构造函数：可以访问静态成员和实例成员，用于初始化实例成员

{

...}

static TestClass()//静态构造函数：只能访问静态成员，用于初始化静态成员

{

...} } 类的静态成员属于类所有，不必生成实例就可以访问，它是在载入包含类的应用程序时创建的，但静态方法不能访问类的实例变量和方法。通常，静态变量是在定义时就赋初始值的。类的实例成员属于类的实例所有，不创建实例对象就无法对其进行访问，实例成员可以访问类的

静态成员和其它实例成员。调用基类的析构函数： class A {

public A()

{

...} } class B {

public B(): base()//调用基类的析构函数

{

...} } 常量：其值是在编译时设定的，必须是数值文字。默认状态下常量是静态的。例： class A {

public const double pi = 3.1415;} 常量是编译时就确定的值，只读字段是在运行才能确定的值。比如运行时才能确定的屏幕分辨率。

只读字段只能在类的析构函数中赋值。静态只读字段： class A {

public static readonly int ScreenWidth;//静态只读字段

static A()

//静态析构函数

{

ScreenWidth = 1024;//在静态析构函数中初始化

} } 在类的继承中，类的析构函数是不会被继承的。一个派生类只能从一个基类继承，不能同时从多个基类继承，但可以通过继承多个接口来达到相同目的。实现多继承的唯一方法就是使用接口。例：

class MyFancyGrid: Control, ISerializable, IDataBound {...} 密封类是不能继承的类，抽象类不能被定义为密封类，且密封类的私有成员不能用protected修饰，只能用private。例： sealed class A {...} 关键字ref和out用于指定用引用方式传递方法的参数。

它们的区别是：ref参数必须初始化，而out参数不需要初始化。所以在方法处理代码依赖参数的初始化值时使用ref，不依赖初始化值时使用out。对out参数即使在传递前对其进行了初始化，其值也不会传递到方法处理函数内部。传递时系统会将其设为未初始化。所以在方法内部必须对out参数进行初始化。

方法重载时，必须参数数目和参数类型其中之一不同，返回值不同不能作为重载。C#不支持方法的默认值，只能通过方法重载来实现。例： class A {

int Method(int a)

{

...}

void Method(int a, int b)//参数数目不同

{

//返回值不同不能作为重载

...} } params参数用于一个不定数目参数的方法，一般后面跟一个数组。例： class A {

public void Method(params int[] i)

{

...} } 方法的覆盖：指派生类覆盖基类的同名方法，有二种方法

1）第一种是在派生类要覆盖的方法前面加new修饰，而基类不需要作任何改动。这种方法的缺点是不能实现多态。例： class A {

public void Method()//无需任何修饰

{

...} } class B: A

//从基类继承

{

new public void Method()//覆盖基类的同名方法

{

...} } class TestClass {

A Instance = new B();

Instance.Method();//这时将调用类A的Method方法，而不是类B的Method方法 } 2）第二种是在派生类要覆盖的方法前面加override修饰，而基类的同名方法前面加virtual修饰。这样就能实现多态，例： class A {

virtual public void Method()

//基类定义虚方法

{

//虚拟方法不能定义为private，因为private成员对派生类是无法访问的...} }

class B: A

//从基类继承 {

override public void Method()

//派生类覆盖基类的同名虚方法

{

...} } class TestClass {

protected void Test()

{

A Instance = new B();

//定义一个实例，类型为基类，从派生类创建

//派生类总是能够向上转换为其基类

Instance.Method();

//将调用派生类B的Method方法，而不是基类的，这就是多态

} } 说明：new修饰的方法覆盖不能实现多态的原因，是因为使用new时编译器只会实现早期绑定（early binding）。即调用的方法在编译时就决定了：编译器看到Instance.Method()而Instance的类是A，就会调用类A的Method()方法。

override修饰的方法覆盖可以实现多态的原因，是因为实现了后期绑定（late binding）。使用override时强制编译器在运行时根据类的真正类型正确调用相应的方法，而不是在编译时。

而基类的同名方法必须加virtual修饰。

类的静态方法可能通过 类名.静态方法名 这种格式来调用，不能使用 实例名.静态方法名 这种方法调用。

因为类的静态方法为类所有（是属于类本身的），而非实例所有（不是属于类的实例的）。类的静态方法可以访问类的任何静态成员，但不能访问类的实例成员。C#中类的变量称为字段。类的public变量称为类的公共字段。

类的属性由一个protected（也可以是private）字段和getter和setter方法构成： class Address {

protected string zipCode;//protected字段，注意大小写

public string ZipCode

{

get

//getter方法

{

return zipCode;

}

set

//setter方法

{

zipCode = value;//被传递的值自动被在这个value变量中

}

};} 只读属性是指省略setter方法的属性，只读属性只能读取，不能设置。

属性也可以用限定符virtual，override和abstract修饰，功能同其他类的方法。

属性有一个用处称为懒惰的初始化（lazy initialization）。即在需要类成员时才对它们进行初始化。如果类中包含了很少被引用的成员，而这些成员的初始化又会花费大量的时候和系统资源的话，懒惰的初始化就很有用了。C#中数组对象共同的基类是System.Array。将数组声明为类的一个成员时，声明数组与实例化数组必须分开，这是因为只能在运行时创建了类的实例对象之后，才能实例化数组元素值。声明：

int[] intArray;//一维数组 int[，] int3Array;//三维数组 初始化：

intArray = new int[3] {1,2,3};int[,] int2Array = new int[2,3] {{1,2,3},{4,5,6}};//声明时可以初始化 遍历：

1）一维数组

for(int i = 0;i < intArray.Length;i++);//Array.Length返回数组所有元素的个数 foreach(int i in intArray);for(int i = 0;i < intArray.GetLength(0);i++);//Array.GetLength(0)返回数组第一维的个数 2）多维数组

for(int i = 0;i < int3Array.GetLength(0);i++)//遍历三维数组

for(int j = 0;j < int3Array.GetLength(1);j++)

for(int k = 0;k < int3Array.GetLength(2);k++)

{

...} 数组的维数就是该数组的秩（Rank）。Array.Rank可以返回数据的秩。锯齿数组（jagged Array）是元素为数组的数组，例：

int[][] jaggedArray = new int[2][];//包含二个元素，每个元素是个数组 jaggedArray[0] = new int[2];//每个元素必须初始化 jaggedArray[1] = new int[3];for(int i = 0;i < jaggedArray.Length;i++)//遍历锯齿数组

for(int j = 0;j < jaggedArray[i].Length;j++)

{

...} 类的属性称为智能字段，类的索引器称为智能数组。由于类本身作数组使用，所以用this作索引器的名称，索引器有索引参数值。例： using System;using System.Collections;class MyListBox {

protected ArrayList data = new ArrayList();

public object this[int idx] //this作索引器名称，idx是索引参数

{

get

{

if(idx >-1 && idx < data.Count)

{

return data[idx];

}

else

{

return null;

}

}

set

{

if(idx >-1 && idx < data.Count)

{

data[idx] = value;

}

else if(idx = data.Count)

{

data.Add(value);

}

else

{

//抛出一个异常

}

}

} } 接口是二段不同代码之间约定，通过约定实现彼此之间的相互访问。C#并不支持多继承，但通过接口可实现相同功能。当在接口中指定了实现这个接口的类时，我们就称这个类“实现了该接口”或“从接口继承”。一个接口基本上就是一个抽象类，这个抽象类中除了声明C#类的其他成员类型——例如属性、事件和索引器之外，只声明了纯虚拟方法。接口中可以包含方法、属性、索引器和事件——其中任何一种都不是在接口自身中来实现的。例：

interface IExampleInterface {

//property declaration

int testProperty { get;}

//event declaration

event testEvevnt Changed;

//mothed declaration

function void testMothed();

//indexer declaration

string this[int index] { get;set;} } 说明：定义接口时，在方法、属性、事件和索引器所有这些接口成员都不能用public之类的访问限定符，因为所有接口成员都是public类型的。因为接口定义了一个约定，任何实现一个接口的类都必须定义那个接口中每一个成员，否则将编译失败。例： using System;public class FancyControl {

protected string data;

public string Data

{

get {return this.data;}

set {data = value;}

} } interface IValidate {

bool Validate();//接口方法

} public class MyControl: FancyControl, IValidate {

public MyControl()

{

data = “my control data”;

}

public bool Validate()//实现接口

{

if(data == “my control data”)

return true;

else

return false;

} } class InterfaceApp {

MyControl myControl = new MyControl();

IValidate val =(IValidate)myControl;//可以将一个实现某接口的类，转换成该接口

bool success = val.Validate();//然后可调用该接口的方法 } 也可以用：bool success = myControl.Validate();这种方法来调用Validate方法，因为Validate在类MyControl中是被定义成public的，如果去除public，Validate方法被隐藏，就不能用这种方法调用了，这样隐藏接口方法称为名字隐藏（name hiding）。可以用：类实例 is 接口名 来判断某个类是否实现了某接口，例： myControl is IValidate //MyControl类的实例myControl是否实现了IValidate接口

当然，也可用as来作转换，根据转换结果是否为null来判断某个类是否实现了某接口，例： IValidate val = myControl as IValidate;if(null == val){...//没有实现IValidate接口 } else {...//实现了IValidate接口

}

如果一个类从多个接口继承，而这些接口中如果定义的同名的方法，则实现接口的方法时，必须加接口名来区别，写成 接口名.方法名。假设Test类从IDataStore和ISerializable二个接口继承，而这二个接口都有SaveData()方法，实现SaveData()方法时必须写成： class Test: ISerializable, IDataStore {

void ISerializable.SaveData()

{

...}

void IDataStore.SaveData()

{

...} } 如果一个类从多个接口继承，为了方便可以定义一个新的接口，这个接口继续多个接口，然后类直接从这个接口继承就可以了，这个叫合并接口。例： interface ISaveData: ISerializable, IDataStore { //不需要定义任何方法或成员，只是用作合并 } class Test: ISaveData //只要继承ISaveData就可以了 {...} C# 操作符优先级（从高到低）

初级操作符()x.y f(x)a[x] x++ x--new typeof sizeof checked unchecked 一元操作符 +位移操作符 << >> 关系操作符 < > <= >= is 等于操作符 == 逻辑与

& 逻辑异或 ^ 逻辑或

| 条件与

&& 条件或

|| 条件操作符 ?: 赋值操作符 = *= /= %= +=-= <<= >>= &= ^= |= 所有的二元操作符除赋值符外都是左联合的，即从左到右计算。

typeof()运算符可以从一个类名得到一个System.Type对象，而从System.Object对象继承来的GetType()方法则可从一个类实例来得到一个System.Type对象。例： Type t1 = typeof(Apple);//Apple是一个类名

Apple apple = new Apple();//apple是Apple类的一个实例 Type t2 = apple.GetType();//t1与t2是相同的 通过反射得到一个类的所有成员和方法： Type t = typeof(Apple);string className = t.ToString();//得到类名

MethodInfo[] methods = t.GetMethods();//得到所有方法 foreach(MethodInfo method in methods){ //用method.ToString()得到方法名 } MemberInfo[] members = t.GetMembers();//得到所有成员 foreach(MemberInfo member in members){ //用member.ToString()得到成员名 } sizeof()操作符用来计算值类型变量在内存中占用的字节数（Bytes），并且它只能在unsafe（非安全）

代码中使用。例：

static unsafe public void ShowSizes(){

int i, j;

j = sizeof(short);

j = sizeof(i);} 尽可能使用复合赋值操作符，它比不用复合赋值操作符的效率高。for语句的语法为：

for(initialization;Boolean-expression;step)

embedded-statement 在initialization和step部份还可以使用逗号操作符，例： for(int i = '0', j = 1;i <= 'xFF';i++, j++)for(int i = 1, j = 1;i < 1000;i += j, j = i!~ ++--true false 二元：+32)/ 9)* 5;

} } 代表的(delegate)目的与C++中的函数指针相同，代表不是在编译时被定义的，而是在运行时被定义的。

代表主要有二个用途：回调(Callback)和事件处理(event)回调通常用于异步处理和自定义处理。例： class DBManager {

static DBConnection[] activeConnections;

//声明回调函数

public void delegate EnumConnectionCallback(DBConnection connection);

public static void EnumConnections(EnumConnectionCallback callback)

{

foreach(DBConnection connection in activeConnections)

{

callback(connection);//执行回调函数

}

} } //调用

class DelegateApp {

public static void ActiveConncetionCallback(DBConnection connection)//处理函数

{

...}

public void main()

{

//创建指向具体处理函数的代表实例（新建一个代表，让它指向具体的处理函数）

DBManager.EmnuConnectionCallback myCallback = new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);

DBManager.EnumConnections(myCallback);

} } //使用静态代表，上面的调用改为 class DelegateApp {

//创建一个指向处理函数的静态代表

public static DBManager.EmnuConnectionCallback myCallback

= new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);

public static void ActiveConncetionCallback(DBConnection connection)

{...} public void main()

{

DBManager.EnumConnections(myCallback);

} } //在需要时才创建代表，上面的调用改为

class DelegateApp {

//将创建代表放在属性的getter方法中

public static DBManager.EmnuConnectionCallback myCallback

{

get

{

retun new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);

}

}

public static void ActiveConncetionCallback(DBConnection connection)

{...} public void main()

{

DelegateApp app = new DelegateApp();//创建应用程序

DBManager.EnumConnections(myCallback);

} } 可以将多个代表整合成单个代表，例： class CompositeDelegateApp {

public static void LogEvent(Part part)

{

...}

public static void EmailPurchasingMgr(Part part)

{

...}

public static void Main()

{

//定义二个代表

InventoryManager.OutOfStockExceptionMethod LogEventCallback

= new InventoryManager.OutOfStockExceptionMethod(LogEvent);

InventoryManager.OutOfStockExceptionMethod EmailPurchasingMgrCallback

= new InventoryManager.OutOfStockExceptionMethod(EmailPurchasingMgr);

//整合为一个代表，注意后加的代表先执行（这里是先执行LogEventCallback）

InventoryManager.OutOfStockExceptionMethod onHandExceptionEventsCallback

= EmailPurchasingMgrCallback + LogEventCallback;

//调用代表

InventoryManager mgr = new InventoryManager();

mgr.ProcessInventory(onHandExceptionEventsCallback);

//InventoryManager类的ProcessInventory方法的原型为：

//public void ProcessInventory(OutOfStockExceptionMethod exception);

} } 可以根据需要将多个代表自由地组合成单个代表，例： class CompositeDelegateApp {

//代表指向的处理函数（三个代表三个函数）

public static void LogEvent(Part part)

{

...} public static void EmailPurchasingMgr(Part part){...}

public static void EmailStoreMgr(Part part)

{

...}

public static void Main()

{

//通过数组定义三个代表

InventoryManager.OutOfStockExceptionMethod[] exceptionMethods

= new InventoryManager.OutOfStockExceptionMethod[3];

exceptionMethods[0] = new InventoryManager.OutOfStockExceptionMethod(LogEvent);

exceptionMethods[1] = new InventoryManager.OutOfStockExceptionMethod(EmailPurchasingMgr);

exceptionMethods[2] = new InventoryManager.OutOfStockExceptionMethod(EmailStoreMgr);

int location = 1;

//再定义一个代表（用于组合成单代表）

InventoryManager.OutOfStockExceptionMethod compositeDelegate;

//根据需要组合

if(location = 2)

{

compositeDelegate = exceptionMethods[0] + exceptionMethods[1];

}

else

{

compositeDelegate = exceptionMethods[0] + exceptionMethods[2];

}

//调用代表

InventoryManager mgr = new InventoryManager();

mgr.ProcessInventory(compositeDelegate);

} } C#的事件遵循“发布——预订”的设计模式。在这种模式中，一个类公布能够出现的所有事件，然后任何的类都可以预订这些事件。一旦事件产生，运行环境就负责通知每个订户事件已经发生了。

当代表作为事件的处理结果时（或者说定义具有代表的事件），定义的代表必须指向二个参数的方法：一个参数是引发事件的对象（发布者），另一个是事件信息对象（这个对象必须从EventArgs类中派生）。例： using System;

class InventoryChangeEventArgs: EventArgs //事件信息对象，从EventArgs类派生 {...//假设定义二个public属性string Sku和int Change } class InventoryManager

//事件的发布者 {

//声明代表

public delegate void InventoryChangeEventHander(object source, InventoryChangeEventArgs e);

//发布事件，event关键字可将一个代表指向多个处理函数

public event InventoryChangeEventHandler onInventoryChangeHander;

public void UpdateInventory(string sku, int change)

{

if(change == 0)

return;

InventoryChangeEventArgs e = new InventoryChangeEventArgs(sku, change);

//触发事件

if(onInventoryChangeHandler!= null)//如果有预订者就触发

onInventoryChangeHandler(this, e);//执行代表指向的处理函数

} } class InventoryWatcher

//事件的预订者 {

public InventoryWatcher(InventoryManager mgr)//mgr参数用于联结发布者

{

this.inventoryManager = mgr;

//预订事件，用 += 调用多个处理函数

mgr.onInventroyChangeHandler += new InventoryManager.InventoryChangeEventHandler(onInventoryChange);

//事件处理函数

void onInventroyChange(object source, InventroyChangeEventArgs e)

{

...}

InventoryManager inventoryManager;

} } class EventsApp

//主程序 {

public static void Main()

{

InventoryManager inventoryManager = new InventoryManager();

InventoryWatcher inventoryWatcher = new InventoryWatcher(inventoryManager);

inventoryManager.UpdateInventory(“111 006 116”,-2);

inventoryManager.UpdateInventory(“111 006 116”, 5);

} } Microsoft Windows NT和IBM OS/2等操作系统都支持占先型多任务。在占先型多任务执行中，处理器负责

给每个线程分配一定量的运行时间——一个时间片(timeslice)。处理器接着在不同的线程之间进行切换，执行相应的处理。在单处理器的计算机上，并不能真正实现多个线程的同时运行，除非运行在多个处理器 的计算机上。操作系统调度的多线程只是根据分配给每个线程时间片进行切换执行，感觉上就像同时执行。

上下文切换(context switching)是线程运行的一部分，处理器使用一个硬件时间来判断一个指定线程的时间片何时结束。当这个硬件计时器给出中断信号时，处理器把当前运行的线程所用的所有寄存器(registers)数据存储到堆栈中。然后，处理器把堆栈里那些相同的寄存器信息存放到一种被称为“上下文结构”的数据结构中。当处理器要切换回原来执行的线程时，它反向执行这个过程，利用与该线程相关的上下文结构，在寄存器里重新恢复与这一线程相关的信息。这样的一个完整过程称为“上下文切换”。多线程允许应用程序把任务分割为多个线程，它们彼此之间可以独立地工作，最大限度地利用了处理器时间。using System;using System.Threading;class SimpleThreadApp {

public static void WorkerThreadMethod()//线程的执行体

{

...//执行一些操作

}

public static void Main()

{

//创建一个线程代表指向线程的执行体，ThreadStart是创建新线程必须用到的代表

ThreadStart worker = new ThreadStart(WorkerThreadMethod);

Thread t = new Thread(worker);//用线程代表创建线程

t.Start();

//执行线程

} } 可以通过两种方式来得到一个Thread对象：一种是通过创建一个新线程来得到，如上例；另一种在正在执行的线程调用静态的Thread.CurrentThread方法。

静态方法Thread.Sleep(int ms)可以让当前线程（它自动调用Thread.CurrentThread）暂停指定毫秒的时间。

如果使用Thread.Sleep(0)那么当前线程将一直处于等待中，直到另一个线程调用这个线程的实例方法Thread.Interrupt方法，等待才会结束。使用Thread.Suspend方法也能挂起线程，Thread.Suspend方法可以被当前线程或其他线程调用，而Thread.Sleep(0)只能由当前线程在执行体中调用。当线程用Thread.Suspend挂起时，必须用Thread.Resume方法恢复。不论Thread.Suspend方法调用了多少次，只要调用Thread.Resume方法一次就可以线程恢复执行。用Thread.Suspend方法并不会阻塞线程，调用立即返回。而Thread.Sleep(0)则会阻塞线程。所以确切地说Thread.Sleep(0)暂停线程，而不是挂起线程。

使用Thread.Abort方法可以终止正在执行的线程。当Thread.Abort方法被调用时，线程不会立即终止执行。运行环境将会等待，直到线程到达文档中所描述的“安全点”。如果要确保线程已经完全停止，可以使用Thread.Join方法。这是一个同步调用，同步调用意味着直到线程完全停止，调用才会返回。

Thread.Priority属性用于设置的线程的优先级。其值是Thread.ThreadPriority枚举值，可以设为Highest, AboveNormal,Normal, BelowNormal, Lowest。缺省值是Thread.ThreadPriority.Normal。

线程的同步是为了解决多个线程同时使用同一对象产生的一些问题。通过同步，可以指定代码的临界区(critical section)，一次只有一个线程可以进入临界区。使用System.Monitor类（锁定与信号量）进行线程同步： using System;using System.Threading;public void SaveData(string text)//线程执行函数或线程执行函数调用的对象的方法 {

...//执行其他一些不需要同步的处理

Monitor.Enter(this);//获取对象的Monitor锁

...//执行需要同步的处理

Monitor.Exit(this);//释放对象的Monitor锁

...//执行其他一些不需要同步的处理

} 说明：当执行Monitor.Enter方法时。这个方法会试图获取对象上的Monitor锁，如果另一个线程已经拥有了这个锁，这个方法将会阻塞(block)，直到这个锁被释放。

也可用C#的lock语句来获得和释放一个Monitor锁。上面同步写成：public void SaveData(string text)//线程执行函数或线程执行函数调用的对象的方法 {

...//执行其他一些不需要同步的处理

lock(this)//获取对象的Monitor锁，代码块执行完成后释放Monitor锁

{

...//执行需要同步的处理

}

...//执行其他一些不需要同步的处理 } 也可以使用System.Threading名称空间的Mutex类（互斥类）进行线程同步。与Monitor锁一样，一次只有一个线程能获得一个给定的互斥。但Mutex要慢得多，但它增加了灵活性。例：

using System;using System.Threading;class Database {

Mutex mutex = new Mutex(false);//创建一个互斥，但不立即获得它

//注意：创建互斥在需要同步的方法之外，实际上它只要创建一个实例

public void SaveData(string text)//需要同步的方法

{

mutex.WaitOne();//等待获得互斥

...//需要同步的处理

mntex.Close();//释放互斥

} } Mutex类重载了三个构造函数：

Mutex()

//创建并使创建类立即获得互斥

Mutex(bool initiallyOwned)

//创建时可指定是否要立即获得互斥 Mutex(bool initiallyOwned, string muterName)//还可以指定互斥的名称 Mutex.WaitOne方法也重载了三次： Mutex.WaitOne()

//一直等待

Mutex.WaitOne(TimeSpan time, bool exitContext)//等待TimeSpan指定的时间 Mutex.WaitOne(int milliseconds, bool exitContext)//等待指定的毫秒 线程的用法：

1)并发操作：比如一个程序监视多个COM口，当每个COM接到信息时执行一段处理时。2)复杂长时间操作：一个长时间的复杂操作可能会使界面停滞，停止用户响应，如果还允许用户停止它，或者显示进度条、显示操作执行进程信息时。

反射(Reflection)就是能够在运行时查找类型信息，这是因为.NET编译的可执行(PE)文件中包括MSIL和元数据(metadata)。

反射的中心是类System.Type。System.Type是一个抽象类，代表公用类型系统(Common Type System, CTS)中的一种类型。

using System;using System.Reflection;//反射命名空间，必须引用 public static void Main(string[] args){

int i = 6;

Type t = i.GetType();

//根据实例得到类型

t = Type.GetType(“System.Int32”);//根据类型的字符名称得到类型

} 通过Assembly类可以得到已经编译.NET Framework程序的中所有类型，例： using System;using System.Diagnostics;//为了使用Process类 using System.Reflection;//为了使用Assembly类 class GetTypesApp {

protected static string GetAssemblyName(string[] args)

{

string assemblyName;

if(0 == args.Length)//如果参数为空，取当前进程的名称

{

Process p = Process.GetCurrentProcess();

assemblyName = p.ProcessName + “.exe”;

}

else

assemblyName = args[0];//取第一个参数，即当前运行程序名

return assemblyName;

}

public static void Main(string[] args)

{

string assemblyName = GetAssemblyName(args);

Assembly a = Assembly.LoadFrom(assemblyName);//调用编译程序集

Type[] types = a.GetTypes();

//得到多个类型

foreach(Type t in types)

//遍历类型数组

{

...//取得t.FullName,t.BaseType.FullName等类型信息

}

} } 一个应用程序可以包括多个代码模块。若要将一个cs文件编译一个模块，只要执行下面的命令：

csc /target:module 要编译的模块.cs //csc是C Sharp Compiler(C#编译器)然后在应用程序中using编译的模块.cs中的NameSpace即可应用了。要反射应用程序中所有代码模块(Module)，只要：

Assembly a = Assembly.LoadFrom(assemblyName);//应用程序的物理文件名 Module[] modules = a.GetModules();foreach(Module m in modules){...//显示m.Name等

} 后期绑定(latebinding),例：

string[] fileNames = Directory.GetFiles(Environment.CurrentDirectory, “*.dll”);foreach(string fileName in fileNames){

Assembly a = Assembly.LoadFrom(fileName);

Type[] types = a.GetTypes();

foreach(Type t in types)

{

if(t.IsSubclassOf(typeof(CommProtocol)))//判断是否有CommProtocol的派生类

{

object o = Activator.CreateInstance(t);//生成实例

MethodInfo mi = t.GetMethod(“DisplayName”);

mi.Invoke(o, null);

//调用方法

}

} } //带参数的例子

namespace Programming_CSharp {

using System;

using System.Reflection;

public class Tester

{

public static void Main()

{

Type t = Type.GetType(“System.Math”);

Object o = Activator.CreateInstance(t);

// 定义参数类型

Type[] paramTypes = new Type[1];

paramTypes[0]= Type.GetType(“System.Double”);

MethodInfo CosineInfo = t.GetMethod(“Cos”, paramTypes);

//设置参数数据

Object[] parameters = new Object[1];

parameters[0] = 45;

//执行方法

Object returnVal = CosineInfo.Invoke(o, parameters);

Console.WriteLine(“The cosine of a 45 degree angle {0}”, returnVal);

}

} } 动态生成代码和动态调用的完整例子： //动态生成代码的部分 using System;using System.Reflection;using System.Reflection.Emit;//动态生成代码必须引用 namespace ILGenServer {

public class CodeGenerator

{

public CodeGenerator()

{

currentDomain = AppDomain.CurrentDomain;//得到当前域

assemblyName = new AssemblyName();//从域创建一个程序集

assemblyName.Name = “TempAssembly”;

//得到一个动态编译生成器，AssemblyBuilerAccess.Run表示只在内存中运行，不能保存

assemblyBuilder = currentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilerAccess.Run);

//从编译生成器得到一个模块生成器

moduleBuilder = assemblyBuilder.DefineDynamicModule(“TempModule”);

//模块生成器得到类生成器

typeBuilder = moduleBuilder.DefineType(“TempClass”, TypeAttributes.Public);

//为类添加一个方法

methodBuilder = typeBuilder.DefineMethod(“HelloWord”, MethodAttributes.Public, null, null);

//为方法写入代码，生成代码必须使用到IL生成器

msil = methodBuilder.GetILGenerator();

msil.EmitWriteLine(“Hello World”);msil.Emit(OpCodes.Ret);//最后还需要编译(build)一下类 t = typeBuilder.CreateType();

}

AppDomain currentDomain;

AssemblyName assemblyName;

AssemblyBuilder assemblyBuilder;

ModuleBuilder moduleBuilder;

TypeBuilder typeBuilder;

MethodBuilder methodBuilder;

ILGenerator msil;

object o;

Type t;

public Type T

{

get

{

return this.t;

}

}

} } //动态调用的部分

using System;using System.Reflection;using ILGenServer;//引用动态生成代码的类 public class ILGenClientApp {

public static void Main（{

CodeGenerator gen = new CodeGenerator();//创建动态生成类

Type t = gen.T;

if(null!= t)

{

object o = Activator.CreateInstance(t);

MethodInfo helloWorld = t.GetMethod(“HelloWorld”);//为调用方法创建一个MethodInfo

if(null!= helloWorld)

{

helloWorld.Invoke(o, null);//调用方法

}

}

} } 调用DLL using System;using System.Runtime.InteropServices;//为了使用DLLImport特性

class PInvokeApp {

[DllImport(“user32.dll”, CharSet=CharSet.Ansi)] //CharSet.Ansi指定Ansi版本的函数(MessageBoxA),CharSet.Unicode指定Unicode版本的函数(MessageBoxW)

static extern int MessageBox(int hWnd, string msg, string caption, int type);//声明DLL中的函数

//[DllImport(“user32.dll”, EntryPoint=“MessageBoxA”)] //用这种方法使用不同的函数名

//static extern int MsgBox(int hWnd, string msg, string caption, int type);

//[DllImport(“user32.dll”, CharSet=CharSet.Unicode)] //调用Unicode版的DLL函数

//static extern int MessageBox(int hWnd, [MarshalAs(UnmanagedType.LPWStr)]string msg，// [MarshalAs(UnmanagedType.LPWStr)]string caption, int type);//将LPWStr翻译为string型，缺省情况系统只将LPStr翻译成string

public static void Main()

{

MessageBox(0, “Hello, World!”, “CaptionString”, 0);//调用DLL中的函数

} } 例2，使用回调： class CallbackApp {

[DllImport(“user32.dll”)]

static extern int GetWindowText(int hWnd, StringBuilder text, int count);

delegate bool CallbackDef(int hWnd, int lParam);

[DllImport(“user32.dll”)]

static extern int EnumWindows(CallbackDef callback, int lParam);

static bool PrintWindow(int hWnd, int lParam)

{

StringBuilder text = new StringBuilder(255);

GetWindowText(hWnd, text, 255);

Console.WriteLine(“Window Caption: {0}”, text);

return true;

}

static void Main()

{

CallbackDef callback = new CallbackDef(PrintWindow);

EnumWindows(callback, 0);

} } 关键字unsafe指定标记块在非控环境中运行。该关键字可以用于所有的方法，包括构造函数和属性，甚至还有方法中的代码块。关键字fixed负责受控对象的固定(pinning)。Pinning是一种动作，向垃圾收集(Garbage Collector, GC)指定一些不能被移动的对象。为了不在内存中产生碎片，.NET运行环境把对象四处移动，以便于最有效地利用内存。使用fixed后指定对象将不会被移动，所以就可以用指针来访问它。

C#中只能得到值类型、数组和字符串的指针。在数组的情况下，第一个元素必须是值类型，因为C#实际上是返回一个指向数组第一个元素的指针，而不是返回数组自身。& 取一个变量的内存地址（即指向该变量的指针）* 取指针所指变量的值-> 取成员

例：using System;class UnsafeApp {

public static unsafe void GetValues(int* x, int* y)

{

*x = 6;

*y = 42;

}

public static unsafe void Main()

{

int a = 1;

int b = 2;

GetValues(&a, &b);

} } fixed语法为：fixed(type* ptr = expression)statements其中type也可以为非控类型，也可是void；expression是任何产生一个type指针的表达式；statements是应用的代码块。例： fixed(int* f = &foo.x)//foo是Foo类的一个实例，x是Foo类的一个int属性 {

SetFooValue(f);//SetFooValue方法的定义为unsafe static void SetFooValue(int* x)} 传统的COM组件可以通过互操作层(COM Interop)与.NET运行环境交互。互操作层处理在托管运行环境和非托管区域中的COM组件操作之间传递所有的消息。

要使COM组件能在.NET环境中使用,必须为COM组件生成元数据。.NET运行环境用元数据层业判断类型信息。在运行时刻使用类型信息，以便生成RCW(Runtime Callable Wrapper,运行时可调用包装)。当.NET应用程序与COM对象交互时，RCW处理对COM对象的装载和调用。RCW还完成许多其他的工作，如管理对象标识、对象生存周期以及接口缓冲区。对象生存周期管理十分关键，因为.NET GC把对象到处移动，并且当对象不再使用时，自动处理这些对象。RCW服务告诉.NET，应用程序正与托管.NET组件交互，同时又使非托管COM组件“觉得”COM对象是被传统的COM客户端调用的。

为了为COM组件生成元数据包装，必须使用tlbimp.exe(TypeLib Importer)工具： tlbimp some_COM.tlb /out:som_COM.dll

第三篇：c#读书笔记

1、.NET平台包括.NET框架和.NET开发工具等组成部分。.NET框架是整个开发平台的基础，包括公共语言运行库和.NET类库。.NET开发工具包括Visual Studio.NET集成开发环境和.NET编程语言。.NET框架(.NET Framework)是.NET开发平台的基础。.NET框架提供了一个跨语言的、统一的、面向对象的开发和运行环境。

2、在Visual Studio.NET集成开发环境下，可以开发多种不同类型的应用程序。最常见的有以下几种。

。控制台应用程序

。Windows应用程序

。ASP.NET网站

3、开发和运行控制台应用程序

创建一个控制台应用程序，主要包含以下步骤：

（1）执行文件—》新建—》项目

（2）打开“新建项目”对话框，在“项目类型”列表中选择Visual c#节点下的Windows，在“模板”窗格中选择“控制台应用程序”项目模板，输入项目的名称、位置及

解决方案名称后，单击“确定”按钮。

（3）在打开的.cs文件中编写代码。

（4）运行程序。执行“调试”—》启动调试菜单命令，编译并运行程序

4、c#程序的基本结构

。using关键字的功能是用于导入其它命名空间中定义的类型，包括.NET类库。例如，代码中使用的console.readline方法实际上是一个简写，其全称是system.console.readline,但由于在代码的开始使用using指令引入了system命名空间，所以后面可以直接使用console.readline来进行输入。

。namespace 即“命名空间”，也称“名称空间”。命名空间是Visual Studio.NET中的各种语言使用的一种代码组织的形式，当编译一个解决方案时，系统会用项目名称做名字，生成一个namespace，并把类都放在这个namespace里面。

第四篇：C#学习心得

集合声明：类B可以换成任意object对象

1、CollectionBase

类A继承CollectionBase类，通过CollectionBase的成员List实现类A的Add(类

B)、Remove(类B)和RemoveAt(类B)方法:

publicvoidAdd(类B newB)

{List.Add(newB);}

publicvoidRemove(类B newB)

{List.Remove(newB);}

publicvoidRemoveAt(int index)

{List.RemoveAt(index);}

在类A中建立索引可以按类似数组的方法访问。

public 类B this[int index]

{get{return(类B)List[index];}

set{List[index]=value;}

}

利用CollectionBase的成员InnerList（ArrayList对象）实现类A的Contains()方法:

publicboolContains(类B newB)

{

returnInnerList.Contains(newB);

}

注意：InnerList是ArrayList类实例，其Contains方法通过调用Object.Equals确定相等性，Equals默认实现仅支持引用相等。对于引用类型，相等定义为对象相等，即这些引用是否引用同一对象。对于值类型，相等定义为按位相等。

可以在类B中重写Object.Equals方法和GetHashCode()方法。publicoverrideboolEquals(objectobj)

{//Check for null and compare run-time types.if(obj == null || GetType()!= obj.GetType())returnfalse;

B b =(B)obj;

return（比较逻辑）;

}

publicoverrideintGetHashCode(){„„}

2、DictionaryBase

类A继承DictionaryBase类，通过DictionaryBase的成员

Dictionary(IDictionary类型的接口)，实现类A的 Add(object key,类B)和Remove(object key,类B)方法:

publicvoidAdd(object key,类B newB)

{Dictionary.Add(key,newB);}

publicvoidRemove(object key,类B newB)

{Dictionary.Remove(key,newB);}

在类A中建立索引可以按类似数组的方法访问。

public 类B this[object index]

{get{return(类B)Dictionary[index];}

set{Dictionary[index]=value;}

}

利用DictionaryBase的接口成员Dictionary实现类A的Contains()方法: publicboolContains(object key)

{

returnDictionary.Contains(key);

}

3、迭代器

对于继承CollectionBase类的A，使用

foreach(BsourceBin类A对象){}

对于继承DictionaryBase类的A，使用

foreach(DictionaryEntrysourceBin类A对象){source.Value.}

对于类迭代，使用方法GetEnumerator()，返回类型是IEnumerator;类成员迭代使用IEnumerable()，返回类型是IEnumerable;

例如继承DictionaryBase类的A的迭代器，public new IEnumeratorGetEnumerator()

{foreach(object b in Dictionary.Values)

yield return(B)b;

}

以后使用foreach循环时，可按照类似继承CollectionBase类的的方式使用。

4、浅度复制与深度复制

浅度复制：简单地按照成员复制对象可以通过派生于System.Object的MemberwiseClone()方法来完成，这是一个受保护的方法，但是很容易在对象上定义一个调用该方法的公共方法例如GetCopy（）。这个方法的复制功能成为浅复制。浅拷贝是对引用类型拷贝地址，对值类型直接进行拷贝，但是string类例外，因为string是readonly的，当改变string类型的数据值时，将重新分配了内存地址。数组、类也是浅度复制，而结构体、数值型、枚举是深度复制。

深度复制：需要深度复制的类A添加ICloneable接口，实现该接口的Clone()方法。

public object Clone()

{A newA=new A();

object []arr=new object[维度];//object 可以是数值类型，string //不能使用newA.arr=arr;因为通过数组名赋值引用同一地址，是浅度复制 arr.CopyTo(newA.arr,0);

returnnewA;}

假设类A中有成员对象类B实例myB，则在类B定义中也要实现ICloneable的Clone()方法，class B:ICloneable

{

public object Clone(){„„}

}

然后在类A的Clone方法中,newA.myB=myB.Clone();

比较

1、is运算符

检查对象是否是给定类型或者是否可以转换为给定类型，是则返回true。 is

如果type是类类型，operand也是该类型，或继承该类型、封箱到该类型，为true 如果type是接口类型，operand也是该类型，或实现该接口的类型，为true 如果type是值类型，operand也是该类型，或拆箱到该类型，为true2、运算符重载

public static 返回类型 operator 需重载的运算符（参数„„）{}

注意不能重载赋值运算符，&&和||运算符，但可重载&和|；有些运算符需成对重载，如“<”和“>”

3、IComparable接口

类A实现IComparable接口的方法intCompareTo(objectobj)后，利用成员为类A的实例的ArrayList或Array类可以调用Sort()方法，按CompareTo(objectobj)的方法排序。

4、IComparer接口

类A实现IComparer接口的方法intCompare(objectx, objecty)后，利用ArrayList或Array类可以调用Sort(IA)方法(IComparer IA=new A())，按

Compare(，)方法排序。注意ArrayList或Array类的实例不一定是类A。也可以在类A中定义一个公用动态接口成员IComparer ID，这样可以直接调用Sort(ID)。另外，在Compare方法中可以调用Comparer.Default.Compare(,)方法，实现特定的关键字排序。Default是Compare类的动态实例。

转换

1、隐式和显示转换

在没有继承关系，没有共享接口的类型之间转换时，必须定义类型之间的隐式和显示转换。public classA

{„„

//定义A到B的隐式转换

public staticimplicit operatorzhuanB(Aa){„„ return }

}

public classB

{„„

//定义B到A的显式转换

public staticexplicit operatorzhuanA(Bb){„„return }

}

2、as运算符

把类型转换为给定类型。

is

operand类型是type类型，或可以隐式转换为type类型，或封箱到type类型 如果不能转换，则表达式的结果是null

异常处理

Exception：所有异常对象的基类。

SystemException：运行时产生的所有错误的基类。

IndexOutOfRangeException：当一个数组的下标超出范围时运行时引发。NullReferenceException：当一个空对象被引用时运行时引发。

InvalidOperationException：当对方法的调用对对象的当前状态无效时，由某些方法引发。

ArgumentException：所有参数异常的基类。

ArgumentNullException：在参数为空（不允许）的情况下，由方法引发。ArgumentOutOfRangeException：当参数不在一个给定范围之内时，由方法引发。

InteropException：目标在或发生在CLR外面环境中的异常的基类。ComException：包含COM类的HRESULT信息的异常。

SEHException：封装Win32结构异常处理信息的异常。

SqlException：封装了SQL操作异常。

常见具体的异常对象:

ArgumentNullException一个空参数传递给方法，该方法不能接受该参数ArgumentOutOfRangeException参数值超出范围

ArithmeticException出现算术上溢或者下溢

ArrayTypeMismatchException试图在数组中存储错误类型的对象

BadImageFormatException图形的格式错误

DivideByZeroException除零异常

DllNotFoundException找不到引用的DLL

FormatException参数格式错误

IndexOutOfRangeException数组索引超出范围

InvalidCastException使用无效的类

InvalidOperationException方法的调用时间错误

NotSupportedException调用的方法在类中没有实现

NullReferenceException试图使用一个未分配的引用OutOfMemoryException内存空间不够

StackOverflowException堆栈溢出

第五篇：普通话测试试题

一.读单音节字词

桩 病 款 牌 付 乖 郑 索 磨 颤 舱 紫 飘 借 笙 卫 准 菌 嘴 颇 约 核 枕 隋 凶 贼 涌 棉 瞬 锅 钓 买 翁 梗 欧 润 量 否 砣 笨 缺 来 二.读词语(共20分)(限时3分钟)

发扬 模型 花蕊 拨拉 配合 旦角儿 快乐 穷忙 调整 恩情 均匀 喧闹 森林 拼音 嫂子 车站 一顺儿平方 谢谢 称赞 两边 峡谷 志气 乔装 蠢蠢 入口 短促 刻苦 刺猬 耐用 瓜分 沸腾 谎言 从而 试卷 拐弯 亲爱 手软 熊猫 总得 具体 脆弱 葬送 落后 需求 拈阄儿 书架 标尺 三.朗读文章

一个夏季的下午，我随着一群小伙伴偷偷上那儿去了。就在我们穿越了一条孤寂的小路后，他们却把我一个人留在原地，然后奔向“更危险的地带”了，等他们走后，我惊慌失措地发现，再也找不到要回家的那条孤寂的小道了。像只无头的苍蝇，我到处乱钻，衣裤上挂满了芒刺。太阳已经落山，而此时此刻，家里一定开始吃晚餐了，双亲正盼着我回家„„想着想着，我不由得背靠着一棵树，伤心地呜呜大哭起来„„

突然，不远处传来了声声柳笛。我像找到了救星，急忙循声走去。一条小道边的树桩上坐着一位吹笛人，手里还正削着什么。走近细看，他不就是被大家称为“乡巴佬儿”的卡廷吗？

四.命题说话

1.我的愿望 2.学习普通话的体验 1.我的愿望 人是要有愿望的，人没了愿望，就像发动机没有了动力，人没愿望，就等于生命缺少了阳光雨露。人在社会上扮演了多重角色，有着多重的愿望。我是一位青年你，我渴求进步；我是一位母亲，我期望女儿健康成长；我是一名教师，我希望我的学生早日成为国家栋梁。我有太多太多的愿望，在这我要说说其中的一个愿望。就说说教师吧。“师者，传道受业解惑也。”师者，既要教书育人，又要教学相长；既要传授知识，又要培养能力。要做好教师，可谓责任重大。自从参加工作做了教师以来，我一直有个美好的愿望：做一名深受学生喜欢的良师益友。多年来我一直在努力，但仍然觉得现实与愿望还有一段差距。要缩短差距，必须做好以下工作：1.热爱教育，注重情感。教学是师生双向的活动，任何一方未做好，都有可能导致教学的失败。一位教育家说，“爱可以弥补天生的缺陷，情可以使寒冷的冬天变得春天般的温暖。”这充满哲理的话语，的确可以启迪许多人的心扉。只要真诚地热爱教育，关心学生，我想对教育的辛勤付出就不会没有回报。2.与时俱进，终身学习。教师绝不能满足现状，要随时学习，及时调整知识结构，以免知识老化。现代是知识经济、信息革命的时代，你若跟不上时代的步伐，定将是社会历史的淘汰者。

3、塑造形象，给人表率。教师的形象，直接或间接地影响着学生的言行举止，甚至影响他一生的理想和信念。教师应时时处处，养成良好的师德规范，无论是言行举止，还是衣着打扮，都要体现新时代教师的精神风貌。给学生和他人留下美好的形象。以上三点，若能做好，我想，要做“良师益友”的愿望终会实现。2.学习普通话的体验

普通话是我国的通用语言，是我们日常交流沟通的工具。我认为学好普通话很重要，尤其是在我们教师的行业中则更重要。我有这样一个体验，我本人有许多错误的读音，好像我在上学时老师就是这样教的。在我的印象中，上学时教我的老师他们以前好像也都读错了。由此，我现在自己当老师了，就别再叫教错自己的学生了。在普通话学习的日子里，我一头扎进书里，早上早起学，下午下班后练。时间过得很充实，通过学习，我已经矫正了许多自己以前的错误读音，同时也增长了许多自己以前不知道的知识。比如语气词“啊” 的变读，再比如关于儿化。要学好普通话，我觉得有这样几条：本人学习普通话的体验，可简述以下几点：1.方言音与标准音冲突较大，要有的放矢地学习。要多与外地人、陌生人交流交谈，养成普通话思维习惯。2.习惯发音与普通话发音有差距，较难纠正。已成习惯的，往往自己难于发现，要勇于交谈，多交流心得体会，不耻下问。3.普通话学习是一个持续的过程，不可中断。如若“两天打渔你，三天晒网”适合很难学好的。4.在不断地听读写看、分析比较的基础上学习。通过学习他种方言和外语进行比较学习，也是一种良好的途径。5.要做生活的有心人，虚心求学，不断上进。只有热爱生活，取人之长，补己之短，才能学有所获。这以上几点是我学习普通话的体验。总之，通过普通话的学习，使我受益匪浅。