第一篇：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.要做生活的有心人，虛心求學，不斷上進。只有熱愛生活，取人之長，補己之短，才能學有所獲。這以上幾點是我學習普通話的體驗。總之，通過普通話的學習，使我受益匪淺。