c#開發之五---c#語言基礎

第一部分  重點基礎

• 基礎部分

1、  快捷鍵

Ctrl+e+d  快速對齊代碼

Ctrl+S    保存

Ctrl+z    撤銷

Ctrl+k+c  注釋代碼

Ctrl+k+u 取消注釋代碼

#region  #endregion 折疊代碼

Ctrl+鼠標滾動  放大，縮小界面

雙擊tab鍵，自動出現console.writeline();

ctrl+.  或者  shift+alt+F10 導入命名空間（using）（當關鍵字下面出現提示的時候）

ctrl+r+e : 自動封裝屬性

2、  數據類型

Int       整型

Double   浮點型，可帶小數

Float     浮點型

String     字符串 ，加雙引號

Char      單個字符，加單引號

Decimal   金錢，錢數后要加”m”

3、“+”號

有一邊有字符類型，起到連接的作用。

兩邊都是數字，就是相加。

3、  占位符”{}”

用在輸出方法中。

例：

String name=”匡“

Int age=30;

Console.Writeline(我叫{0}，我今年{1}，name,age);

4、  輸入、輸出

Consoe.writeline(“請輸入您的姓名”)；//提示輸入姓名，把這行字顯示到顯示屏上

String name=Consle.readline();       //定義一個name字符串變量，把輸入的值存入變量

Consoe.writeline(“您的姓名是{0}”,name)；

Console.readkey();

5、  轉義符\+特殊字符組成有特殊意義的字符\n   換行

\r\n windows系統的換行

\t   TAB鍵的空格

\”   雙引號

\b   表示一個退格符

\\   表示右斜杠。

6、@

@  取消\在字符中的轉義作用，例   sting str=@”f:\file\rmvb\1.rmvb”;一般在有路徑的情況下加@符號，取消右斜杠的轉義作用。

@還可以保留原格式輸出

7、  轉換

(1)隱式轉換  (小的轉換成大的，可以自動隱式轉換，如int轉換成double， double就不能隱式轉換成int)

Int a=3

Double b=3.14

double c=a*b  //隱式把int 的變量a，轉換成double類型。

（2）顯示轉換(大的轉成小的，就必須顯式轉換,必須兼容)

Int a=3

Double b=3.14

Int c=a*(int) b  //顯式的把double轉換成int類型

（3）convert 轉換(類型不兼容的情況下用，但也有限制，如不能把字符abc，轉換成double或int)

String s=”123”;

Double d=Convert.ToDouble(s);//把string類型的變量轉換成double類型，賦值給變量d.

Int c=Convert.ToInt32(s);     //把string類型的變量轉換成int類型，賦值給變量c.

8、++，--

（1）++

例：

Int a=10；

Int b=10+a++;

上面這一個語句，可以用下面兩條語句表達:

{int b=10+a;  //此時b=20

a++;       //此時a=11,  a++即a=a+1

}          

例：

Int a=10；

Int b=10+ ++a;

上面這一個語句，可以用下面兩條語句表達:

{

a++;       //此時a=11,  a++即a=a+1

int b=10+a; //此時b=21

}          

++在前，即先自身加1，再參加運算。

++在后，即先用原值參加運算，然后自身再加1.

9、  關系表達式和布爾關型

==

> 

< 

>=

<=

!=

關系運算符連接的表達式，稱之為關系表達式。關系表達式的結果只有對和錯兩種。用布爾類型來反應。

例：

Bool b=38>39;  //因為38小于39，所以這是b的值為False.

10、             邏輯運算符

一般兩邊是布爾類型或關系表達式。

&& 與

||   或

！   非

11、             復合賦值運算符

+=

-+

*=

/=

%=

11、調試

（1）F11單步調試：從頭至尾一行一行的調試。

（2）F10  方法調試

（3）    斷點調試，先在想設斷點的代碼左邊點擊鼠標，再點擊啟動，然后再按F11一步一步調試。

可以在調試，窗口中，調出監視窗口來監視變量

• 語句

1、if else

(1)    if

if（判斷）  //判斷為真執行下面的語句。判斷為真后，只執行一遍下面的語句，不循環。

{  }

（2）if else

If(判斷)   //判斷為真執行下面的語句，為假則執行ELSE里的語句。

{   }

Else

{  }

注意，else語句匹配離他最近的if語句。

（3）if   else-if   //如果第一個if判斷為真，則執行下面大括號的語句，然后跳出，不進行后面的所有判斷。

If(判斷)   //主要用來處理多條件區間性判斷。多條件固定值判斷一般用switch 

{   }

Else if (判斷)

{  }

Else if (判斷)

{  }

…….

Else

{  }

2、switch

switch(變量或表達式的值)  //先算出變量或表達式的值，然后用算出的值與下面catch語句里的值進行匹配，匹配成功，就執行后面的代碼，遇到break語句，跳出switch語句。如果不成功繼續與下面的catch里的值進行匹配，直到匹配為止，如果都不匹配，則看是否有default語句，有的話就執行default語句中的代碼，然后跳出switch。

catch 值1：要執行的代碼

break;

catch 值2：要執行的代碼

break;

catch 值3：要執行的代碼

break;

……

default：要執行的代碼     //都不匹配就執行default里的代碼

break;

3、  while

（1）while

while(循環條件)  //當判斷循環條件成立時，則執行下面的循環體，執行完循環體中的代碼后，再進行循環條件判斷，如成立，繼續執行循環體，如不成立則跳出while。循環條件一般為布爾類型或表達式。

{ 循環體

}

（2）do while

Do

{ 循環體}

While(循環條件)  //先執行一遍循環體，再進行循環條件的判斷，判斷為真繼續執行循環體，否則跳出do while循環。

4、  for  （已經知道循環次數時用for）

for (表達式1，表達式2，表達式3)

{循環體}

表達式1為聲明循環變量，計錄循環次數。如，int i=0

表達式2為循環條件,如i<10

表達式3為改變循環條件的代碼，使循環條件終有不成立的時候，如i++。

5、  break和continue

(1)    break

跳出當前循環體，不再循環。一般不單獨出現，和if一起用，當滿足某種條件是跳出循環體。

（2）continue

跳出本輪循環，重新檢測循環條件，繼續下一輪循環。一般也和if一起用。

Break和contunue的區別好比跑步，如果要跑100圈，當跑到10圈遇到break時，直接不跑了，干其他沒干完的事去了。而遇到continue時，你只是臨時下場，這一圈不跑了，然后再上場接下來跑余下的90圈。

三、異常

1、try  catch finally

try              //捕捉異常，包含被異常保護的代碼

{   }

Catch （可帶異常變量，匹配執行某類型的異常）        //如果出現異常，將執行的代碼

{   }

Catch （可帶異常變量，匹配執行某類型的異常）        //如果出現異常，將執行的代碼

{   }

……

Finally           //不管出不出現異常，都將執行的代碼

{   }

2、throw

• 數據類型詳解

（一）  數據類型簡介

浮點型：

Float

Double

Decimal

整數型：

Int

Uint

Long

Short

……..

非數值型：

Bool 布爾

Char 單個字符

用戶自定義類型：

類 class

結構 struct

枚舉 enum

委托 delegate

接口 interface

數組 arry

(二)數據類型詳解

1、  常量   用在不更改的數據上面。如超市統一的打折率。

Const 變量類型  變量名=值；  //常量聲明時必須賦值，且賦值后就不能再更改。

Const int number=50;          //值就一直為50，不能重新賦值。

Number=40 //這就會出錯。不能改。

2、  枚舉

（1）語法：

[public] enum 枚舉名：枚舉值類型  （一般枚舉值類型是省略的）

{

         值1,                //默認為值1=0;

         值2,                //默認為值2=1;

         值3,                //如果此處值3=10;，則值4=11,以此類推。

         ........

}

public:訪問修飾符。公開的公共的，哪都可以訪問。

enum：關鍵字，聲明枚舉的關鍵字

枚舉名：要符合Pascal命名規范

枚舉是值類型，和Int等類似。

枚舉只能存儲同一類型的數據。

（2）枚舉的轉換

Int類型可以和枚舉互轉。

枚舉可以轉換成字符串類型，用tostring（）方法。

字符串類型轉換成枚舉類型時用parse（）方法。

3、  結構

語法：

[public] struct 結構名

{

         成員;//字段,默認是Private類型，要想對外可訪問，要加Public。

}

變量在程序運行期間只能存儲一個值，而字段可以存儲多個值。

4、  數組

數組類型[] 數組名=new 數組類型[數組長度];

二維或三維就是增加[]，

如int [][] number=new int[2][3];//二維數組,兩列三行的數組，實例化是一定要指定長度，或直接初始化。

***數組的長度一旦固定了，就不能再被改變了

5、  事件

• 方法（函數）就是將一堆代碼進行重用的一種機制。

1、  方法的語法：

函數的語法：

[public] static 返回值類型 方法名([參數列表])

{

         方法體；

}

public:訪問修飾符，公開的，公共的，哪都可以訪問。

static：靜態的

返回值類型：如果不需要寫返回值，寫void

方法名：Pascal 每個單詞的首字母都大些。其余字母小寫

參數列表：完成這個方法所必須要提供給這個方法的條件。如果沒有參數，小括號也不能省略。

方法寫好后，如果想要被執行，必須要在Main()函數中調用。

2、  方法的調用與傳遞

類名.方法名([參數]);

在某些情況下，類名是可以省略的，如果你寫的方法跟Main()函數同在一個類中，這個時候，

類名可以省略。

參數傳遞方法有：

值傳遞

引用傳遞

當方法聲明有返回值類型時，方法體中一定要用return返回一個同類型的值。

3、  Ref

引用參數，傳輸的是變量的地址值，所以不管是調用代碼中，還是方法體內的更改，值變量值都會發生改變。

reft參數一定要在方法外賦值，方法內可以不用賦值。如在調用代碼中先賦值。

可以把值傳進方法，也可以把值從方法中傳出來。

staticvoid Main(string[] args)

        {

            double salary = 5000;

            JiangJin(ref salary);//雖然沒有返回值，但代碼中調用jiangjin方法后，salary的值變成了5500.

            Console.WriteLine(salary);//此處值為5500。

            Console.ReadKey();

        }

        publicstaticvoid JiangJin(refdouble s)//此時是參數S的地址值，所以此方法中如果改變了參數的值，在調用代碼中也會改變。所以此處也沒有返回值。

        {

            s += 500;

        }

4、  Out

傳輸多余的變量值到調用代碼中，只能把方法內的數據傳出去，不能傳進來。

一般用在一個方法中需要返回多個數據類型的值時。如既需要string類型，也需要返回int類型時。

調用的方法中有out關鍵時，調用代碼中也需要加上out關鍵字

out參數一定要在方法內初始化賦值。

{          Console.WriteLine("請輸入用戶名");

            string userName = Console.ReadLine();

            Console.WriteLine("請輸入密碼");

            string userPwd = Console.ReadLine();

            string msg1;  //此處可以賦初值也可以不賦初值，因為此參數是out實參，out實參在方法體中會賦初值，且會把最終返回值到此處。且實參名不必和形參名一樣，但實參一定要聲明不可省略。

            bool b = IsLogin(userName, userPwd, out msg1);//調用IsLogin函數，傳遞實參到方法的形參中去。此處調用方法的返回值是bool類型，而多余返回值為msg1是string類型。且此處一定要加上out關鍵字。

            Console.WriteLine("登陸結果{0}",b);

            Console.WriteLine("登陸信息{0}",msg1);

            Console.ReadKey();

        }

        ///<summary>

        ///判斷登陸是否成功

        ///</summary>

        ///<param name="name">用戶名</param>

        ///<param name="pwd">密碼</param>

        ///<param name="msg">多余返回的登陸信息</param>

        ///<returns>返回登陸結果</returns>

        publicstaticbool IsLogin(string name, string pwd, outstring msg)//此方法的返回值為bool類型，同時傳遞兩個參數值和一個多余參數值過來，返回時，會返回一個bool類型的方法返回值，還會多余返回一個string類型的返回值。且多余返回形參前面一定要加Out關鍵值。

        {

            if (name == "admin" && pwd == "888888")

            {

                msg = "登陸成功";                           //給out參數賦值。

                returntrue;

            }

            elseif (name == "admin")

            {

                msg = "密碼錯誤";                         /給out參數賦值。

                returnfalse;

            }

            elseif (pwd == "888888")

            {

                msg = "用戶名錯誤";

                returnfalse;

            }

            else

            {

                msg = "未知錯誤";

                returnfalse;

            }

5、  Pars

6、  方法重載

概念：方法的重載指的就是方法的名稱相同給，但是參數不同。

參數不同，分為兩種情況

1)、如果參數的個數相同，那么參數的類型就不能相同。

2)、如果參數的類型相同，那么參數的個數就不能相同。

***方法的重載跟返回值沒有關系，即如果僅僅返回值不同，構成不了重載。

7、  方法的遞歸

自已調用自已。

要考慮到入口，再考慮到出口。即一定要考慮到什么時候停止調用自已。不然就死循環了。

你調用多少次遞歸，就要有多少次返回。如你畫圈，調用遞歸你畫了十層圈，你不能通過return就立即跳出十層圈，而是得一層一層的跳，要跳十次才能跳出。

六、類

1、  基本語法

[public] [static]class 類名

{

         字段;       //在外面叫變量，在類里叫字段。在類里如果不加修飾符，默認為private。

         屬性;       //實質上就是get和set方法，主要是為了保護字段。

         方法;       //實現方法。

構造函數;   //主要是初始化類，如果不定義構造函數，系統會自動生成一個默認的。

析構函數;   //釋放類的資源和空間。

}

創建類的對象過程，叫類的實例化。

2、  修飾符

Public:公開的。類里的成員可訪問、類外的成員可以通過類對象訪問、派生類的成員可以直接訪問。

 Private:私有的，只在當前類內部訪問。只有類里的成員可以訪問，就算是本類的實例化對象也不能訪問。

Protected：保護的，只有當前類內部和派生類（子類）可以訪問，孫子輩也可訪問。。

Internal:當前程序集中訪問。（當前項目中訪問），在同一項目中，和public權限是一樣的。修飾類時，不加修飾符時，Internal是默認修飾符。

Protected internal:protected+internal的權限。

只有public 和intenal可修飾類類型，如： public class test(){};

子類的訪問權限不能高于基類，會暴露父類的成員。

3、屬性（在字段下按快捷鍵ctrl+r+e快速實現屬性。）

Set 和Get的應用

一般面向對象編程語言都要求成員變量不能直接暴露給外部訪問，如下：
public class A
{
    public int Age;   //這是不好的，待會有程序員可能把-1賦給Age
}
為了防止亂賦值，C#設計了一個屬性機制，要求把成員變量設為私有，在通過屬性來控制成員變量的讀寫，如下：
public class B
{
    private int age;  //私有成員字段
    public int Age    // age的屬性，字段的屬性名一般是把字段名首字母大寫。此聲明等同于public int Age(int value)，value是隱含參數，只是不寫出來。
    {
        get{ return age; }  //讀取器,當代碼中調用屬性時，啟動get方法，在get方法中也可以寫判斷語句，賦值等，和set一樣。在get里有判斷的話，判斷類中的字段。
        set{                //寫入器，當代碼中給屬性賦值時，調用set方法。在set中就判斷value
            if(value>0)
              age = value;   //value是準備寫入的值
        }
    }
}
這樣Age就像保安一樣，擋在age的前面。訪問age的時候需要通過Age許可，如下：
B b = new B();
b.Age = -1;  //這是不行的，-1被帶入value，value<0，判斷不成立
b.Age = 10;  //這是可行的，當給屬性賦值時調用屬性的set方法。把10傳到Age屬性的value隱形參數中，并且調用set方法。

Consloe.WriteLine(“請輸入年齡{0}”,b.Age)//此時調用Age屬性中的get方法，調用時只調用屬性，不會直接調用私有化的字段

屬性中set和get不是必須都需要的，但必須有其中一個。如果只有set方法就是只寫屬性，如果只有get方法，就是只讀屬性。

屬性的作用就是保護字段、對字段的賦值和取值進行限定。

屬性的本質就是兩個方法，一個叫get()一個叫set()。

既有get()也有set()我們誠之為可讀可寫屬性。

只有get()沒有set()我們稱之為只讀屬性

沒有get()只有set()我們稱之為只寫屬性

4、靜態static和非靜態

內存的區域：

棧：存儲值類型，如Int，enum,struct

堆:存儲引用類型，如string,interface,class ,arry，dynamic,object等。即在棧里只有一個指針，指針指向堆里的地址，所有的數據都存在堆里。

靜態存儲區域：存儲靜態類型。靜態存儲區域所有項目成員都可以訪問，所以靜態成員在整個項目中資源共享。且靜態成員在代碼編譯時就分配了內存空間，而非靜態成員只有在編譯后才分配內存空間，所以靜態成員無法調用非靜態成員，因為非靜成員有可能當時還沒有生成。且只有當程序完成后才會釋放空間。所以靜態類型占用內存。

一般在你想做一個工具類時，即大家都會經常用到的類時，才會寫成靜態類。

非靜態類中：

1)、在非靜態類中，既可以有實例成員，也可以有靜態成員。

2)、在調用實例成員的時候，需要使用對象名.實例成員;

    在調用靜態成員的時候，需要使用類名.靜態成員名;

總結：靜態成員必須使用類名去調用，而實例成員使用對象名調用。

           靜態函數中，只能訪問靜態成員，不允許訪問實例成員。

     實例函數中，既可以使用靜態成員，也可以使用實例成員。

靜態類中：

只能有靜態成員，不能出現實例成員。

靜態類不能被實例化。

5、構造函數

構造函數的作用是初始化類。

構造函數不能有返回值，連void也不行。

構造函數名和類名一樣。

靜態構造函數：

主要為類的靜態字段進行初始化

一個類只能有一個靜態構造函數，且不得帶參數，不能有訪問修飾符，如public。

6、析構函數

7、this

表示當前類的對象，類不占內存，但對象占內存。

只能用在：實例構造函數、實例方法以及屬性和索引器的實例訪問器。

8、partial部分類

在一個類中可以寫兩個完全相同的類，并且類與類之間的所有數據都可以共享，你就可以把他當成一個類，只是有兩個地方。類名前加上關鍵字partial。

9、sealed密封類

不能夠被其他類繼承，但是可以繼承于其他類。

Public sealed class preosn()

{};

七、繼承

1、子類繼承的內容:

(1)子類繼承了父類的public字段、屬性和方法，但是子類并沒有繼承父類的私有字段。

(2)子類不繼承父類的構造函數，但調用父類的無參構造函數，以創建父類對象，以使子類可能使用父類中的成員。所以，如果在父類中重新寫了一個有參數的構造函數之后，那個無參數的就被干掉了，子類就調用不到了，所以子類會報錯。

解決辦法：

在父類中重新寫一個無參數的構造函數。

在子類中顯示的調用父類的構造函數，使用關鍵字:base()

2、繼承的特性

繼承的單根性，一個子類只能有一個父類。

繼承的傳遞性，從父類繼承的內容，可以被自已的子類繼承。

3、  object是所有類的基類

4、  語法：

Public class 類名：父類名   //注意，這里的修飾符要比父類的一致，或比父類的權限小，不能比父類的權限大。

5、  如果子類有與父類一樣的方法，將隱藏父類的方法，即把父類覆蓋了。

6、  要顯示的隱藏父類中的方法，可以在子類的方法名前加關鍵字new.

7、子類的實例化對象可以賦值給父類的實例化對象。但父類的不能賦值給子類。

八、多態性

1、  虛函數

(1)    語法

在基類中把虛函數加上關鍵字virtual，在子類中在函數前加上關鍵字override。

例：

Public class animal

{

Public virtual void test ()   //基類中聲明時加上關鍵字，聲明成虛函數。

{

Console.writeline(“我是父類的”)

}

}

Public class cat:animal

{

  Publicoverride void test()//子類中加上override重寫虛函數。這里也可以不加，但不加的話就要加上關鍵字new，把父類的函數隱藏。即子類可以重寫父類的虛方法，也可以不重寫。

{

Console.writeline(“我是子類的”)

}   

Animal aa=new cat();   //把子類對象賦值給父類對象。

aa.test();  //調用子類中的test方法。執行過程如下：

程序執行到此處，跳轉到父類的test函數上，但不執行父類的函數體，接著就跳到子類cat的 test函數上，并且執行函數體。  即此處aa對象賦的是哪個類的對象值，就執行哪個類中的虛函數。

（2）虛函數的作用

子類繼承了虛函數后，子類可以重寫虛函數，也可以不重寫，實現多態性。

當父類的虛函數的實現也有作用時，用虛函數。子類繼承了虛函數后重寫虛函數。

虛函數就是用

（3）注意事項

子類中的虛函數要和父類的一致，即子類中的虛函數和父類中虛函數的返回值，類型，參數都要一致。

2、  抽象類

(1)    語法：

父類：

public Abstract  class animal             //在抽象類前面加上abstract關鍵字。

{

Public Abstract void test(int i);         // 抽象方法前面也加上abstract關鍵字。修飾符不能是private。抽象方法是不能有方法體的，連大括號都不能有。所有的抽象成員在子類中必須被重寫。

Public void sum()                 //抽象類中允許有非抽象方法和非抽象字段，屬性。

{   }

}

Animal dog=new animal();       //這是錯誤的，抽象類是不能被實例化的。

子類：

Public class cat:animal

{

Public Override void test(int j)       //子類中用override重寫抽象方法，且父類中的所有抽象成員必須在子類中重寫。

 {   }

public Override num()            //這種寫法是錯的，抽象方法只能出現在抽象類中。除非子類也是抽象類。

{   }          

}

(2)    注意事項：

1.抽象成員必須標記為abstract,并且不能有任何實現。

2.抽象成員必須在抽象類中。

3.抽象類不能被實例化

4.子類繼承抽象類后，必須把父類中的所有抽象成員都重寫。

（除非子類也是一個抽象類，則可以不重寫）

5.抽象成員的訪問修飾符不能是private

6.在抽象類中可以包含實例成員。

并且抽象類的實例成員可以不被子類實現

7.抽象類是有構造函數的。雖然不能被實例化。

8、子類重寫父類的虛函數時，必須與父類一致，即返回值類型，參數及參數類型都要保持一致。

--------------------------------------------------------------------------------------------------------------------------------

如果父類中的方法有默認的實現，并且父類需要被實例化，這時可以考慮將父類定義成一個普通類，用虛方法來實現多態。

如果父類中的方法沒有默認實現，父類也不需要被實例化，則可以將該類定義為抽象類。

3、  接口

（1）      語法：

Public interface ikoulan

{

Void koulan();   //接口中的函數和抽象函數一樣，不能有方法體。繼承接口的子類，必須實現接口中的所有成員。接口不能被實例化。前面不能加修飾符，默認是public.

String daqui(); //接口中只能有方法、屬性、索引器、事件成員，不能有構造函數和字段。

}

Public class prson:ikoulan

{

Public void koulan()  //這是prson類已有的函數。當人類里面已有一個koulan函數時，就要另外顯示的實現接口函數，在函數前加上接口名。

{

}

Void ikoulan:koulan()                       //一定要實現接口中的成員。因為子類中已有相同名的函數名，所以在這里顯示的加上接口名。如沒有得復不用加接口名。

{

Console.writeline(“高個可以扣籃”);

}

}

在main函數中：

Ikoulan test=new prson();  //接口不可以實例化，但是可以把子類的對像賦值給接口對象。

（2）      用法

當想多繼承時，就需要用到接口，因為類是單繼承的，只能用接口來實現多繼承。

接口就是一種規范，能力。

接口與接口之間可以繼承，并且可以多繼承，即一個接口可以繼承多個接口。

接口并不能去繼承一個類，而類可以繼承接口  （接口只能繼承于接口，而類既可以繼承接口，也可以繼承類）

當幾個類提取不出來一個父類，但有一個共同的行為時，用接口。

當幾個類能提取出一個父類，且有這幾個子類都必須執行的方法，但是不知道這方法怎么實現時，就用抽象類，實現多態性。

當幾個類能提取出一個父類，且有這幾個子類都必須執行的方法，且知道怎么實現這個方法，還想實例化父類時，就用虛函數實現多態性。

（3）      注意事項。

八、集合與泛型

很多數據的集合，和數組類似。

數組長度不可變，類型單一。

集合的長度可以任意改變，類型隨便。

1、  Arraylist

方法：

（1）      ADD方法：把單個元素添加到集合中。

 ArrayList list=new ArrayList();

  List.Add(1);          //添加整型數據到List集合

 List.Add(“張三”);     //添加字符串到List集合

 List.Add(new int[]{1,2,3,4,5}); //添加數組到List集合。此時如果遍歷List時，會顯示數組的命名空間名字，而不會顯示數組中的元素。要解決這個問題，要用addrange方法。

（2）    AddRange方法用于添加一批元素到當前列表的末尾

List.AddRange(new int[]{1,2,3,4,5}); //添加數組到List集合。

List.AddRange(list);           //把自已添加到自已的集合里面。

（3）    Remove方法用于刪除單個元素，通過元素本身的引用來刪除

List.Remove(“張三”);     //寫誰就刪誰。

（4）    RemoveAt方法用于刪除一個元素，通過索引值來刪除，即下標。
List.RemoveAt(0);      //會刪除List.Add(1)中的1，他是第List中的第一個元素。

（5）    RemoveRange用于刪除一批元素，通過指定開始的索引和刪除的數量來刪除

List.RemoveRange(0，3);  //刪除list中第1個元素開始后的三個元素。

（6）    Insert在指定的索引位置插入元素，列表后面的元素依次往后移動

List.Inset（3，“李四”）; //在第4個元素后插入字符串李四。

（7）    InsertRange在指定的索引位置插入一批元素（在集合中插入集合），列表后面的元素依次往后移動

List.InsetRange(1,new string[]{“王五”,趙六”,”李七”}); //在第2個元素后插入字符串數組。

（8）    Clear方法用于清除現有所有的元素

（9）    Contains方法用來查找某個對象在不在列表之中，即判斷集合中是否包含指定的元素。

Bool a=list.contains(“李七”);   是否包含李七，包含為1，不包含為0，即假。

（10）  sort升序排列集合，但要求集合中的元素的類型基本一致才可行。

（11）  count：表示集合中實際包含的元素的個數

（12）  capacity：集合中可以包含的元素的個數。當實際包含的元素個數超過可包含的元素個數時，集合會向內存中申請多開辟一倍的空間來保證集合的長度一直夠用。

（13）遍歷arraylist集合：

For(i=0;i<list.count;i++)   //list.count表示集合的長度

{

Console.writeline(list[i]);

}

2、hashtable  鍵值對集合，類似于字典，根據鍵找到值，鍵和值一一對應。

(1)  方法：

Hashtable ht=new hashtable();

Ht.Add(1,”張三”);       //添加值到集合中

Ht.Add(2,”李四”);

Ht.Add(false,”錯誤”);  //鍵是false

Ht[true]=”正確”;      //也可以通過賦值方法來添加元素到集合中。

Console.writeline(ht[1]);  //打印出鍵為1的值，會顯示出 張三。

Ht.clear();            //清除所有元素

Ht.remove(3);        //根據鍵來清除單個元素。

 （2）遍歷集合

Foreach(var item in htlist)      //用foreach循環來遍歷hashtable集合。

Foreach(var item in ht.keys)  //keys屬性是指hashtable集合的鍵，即遍歷整個集合的鍵

{

Console.writeline(“鍵是{0}，值是{1}”，item,ht[item]);  //同時顯示鍵和值。Item代表了鍵，而ht[item]代表了每個鍵對應的值。

}

（3）鍵值對集合中鍵必須唯一

鍵值對集合中，鍵必須是唯一的，值可以重復。所以添加元素到集合中時，先判斷鍵是否已存在。

If(ht.containsky(“true”))   //如果ht集合中已包含鍵true。

3、  list泛型集合

（1）泛型集合的要點：

要指定集合的類型，集合中的元素都要是這個類型的。

與arraylist的不同之處就是要指定元素的類型，其他方法基本一樣。

List泛型集合可以轉換成數組，數組也可以轉換成集合。

（2）建立list集合對象：

List<int> list=new list <int>();   //聲明一個List集合，<>號中指定元素的類型。

（3）集合轉數組和數組轉集合

   Int[] num=List.toarray();    //用toarray方法把list集合轉換成數組，轉換成什么類型的數組取決于你是什么類型的集合。

   Char[]chs =new char[]{‘a’,’b’,’c’};

   List<char>listchar=chs.ToList();   //用ToList方法把數組轉換成集合。

4、  字典集合

(1)    字典集合的要點：

與hashtable集合使用方法完全一致，只是鍵和值指定了類型

鍵也必須是唯一的

（2）建立字典集合對象

Dictionary<int,string>dic=newDictionary<int,string>();

(3)兩種遍歷方法

方法一：

Foreach(var item in dic.keys)

{

Console.wirteline(“鍵是{0}，值是{1}”,item,dic[item]);

}

     方法二：

   Foreach(keyValuePair<int,string>kv in dic)   //keyvaluepair表示鍵值對，既表示鍵也表示值，所以這種方法可以讓鍵和值一起顯示。

{

console.writeline(“鍵是{0}，值是{1}”，kv.key,kv.value);

}

九、轉換

1、裝箱、拆箱

裝箱：將值類型轉換成引用類型。

拆箱：把引用類型轉換成值類型。

2、里氏轉換

（1）子類可以賦值給父類。

父類：

Public class person

{

  Publicvoid sayhello()

  {

    Console.writeline(“我是中國人”);

  }

}

子類一：

Public class hubie:person

{

  Publicvoid sayhello()

  {

    Console.writeline(“我是湖北人”);

  }

}

子類二:

Public class jiangsu:person

{

  Publicvoid sayhello()

  {

    Console.writeline(“我是江蘇人”);

  }

主函數：

Person china=new hubei();    //把子類對象賦值給父類。如果有一個地方需要父類作為參數，可以用一個子類對象代替。

（2）如果父類中裝的是子類對象，可以將這個父類強轉為子類。

jiangsu js = (jiangsu)china;  //父類對象中裝的是哪一個子類成員，才能轉換成哪個子類的。這里的父類對象china前面被賦的值是hubei子類的，所以要強轉成jiangsu子類的，會出錯。

            hubie hb = (hubie)china;//這個會成功。

（3）IS

if (china isjiangsu)   //is的作用是，如果轉換目標成功，則返回一個true. 先判斷再轉，避免拋異常。

            {

                jiangsu js = (jiangsu)china;   

            }

            else

            {

                Console.WriteLine("轉換失敗");

            }

（4）AS

jiangsu js1 = china asjiangsu; //作用是，如果轉換成功就繼續執行，如果不成功剛返回值null。不會拋異常。這里js1的值就會是null.

十、委托

十一、反射

第二部分：文件、目錄及文件流的操作

• 文件的操作

1、  創建文件

File.create(@”c:\test\test.txt”).close();    //@是去除轉義符。建好后就關閉，否則如果后面要寫入內容就會出錯。

2、  刪除文件

File.Delete(@”c:\test\test.txt”);   

3、  復制文件

File.Copy(@”C:\test\test.txt”,@”c:\test\new.txt”); //復制文件并更名。

4、  移動文件或重命名

File.Move(@"d:\site\file\test7.txt", @"D:\site\file\newfile\test7.txt");

5、判斷

if(File.Exists(@"d:\site\file\my.txt"))       //判斷文件是否存在，如果存在先刪除再建立。不存在，直接建立。

           {

               File.Delete(@"d:\site\file\my.txt");

               File.Create(@"d:\site\file\my.txt").close();

           }

            else

            {

                File.Create(@"d:\site\file\my.txt").close();

}

6、讀取文件

（1）   File.ReadAllText(path); //讀取文件中的內容，但把所讀到的所有內容當一個字符串處理。返回值是字符串，不是字符串數組和集合。

（2）   File.ReadAllLines(path);//讀取文件中的內容，但把每一行當一個字符串，返回值是一個字符串數組。

7、寫入數據  //寫入數據會覆蓋原有的數據

（1）File.WriteAllLines(path,string[]);  //path是文件路徑，string[]是要寫入的字符串數組，一定要是數組。

（2）File.WriteAllText(path, string);  //path是文件路徑，string是要寫入的字符串。

8、追加數據  //追加數據是添加在后面，不會覆蓋原有數據。

（1）File.AppendAllLines(path,string[]);  //path是文件路徑，string[]是要寫入的字符串數組，一定要是數組。

（2）File.AppendAllText(path,string); //path是文件路徑，string是要寫入的字符串。

9、設定文件屬性

File.SetAttributes(path,FileAttributes.ReadOnly);//可以設置文件屬性為只讀，可寫，隱藏等。

10、綜合例：

staticvoid Main(string[] args)

        {

            string path = @"d:\site\file\my.txt";  //把常用的路徑定義成一個字符串。

            string all = "";       //為遍歷字符串拼接字符串賦一個空字符串。一定要先賦值。

           if(File.Exists(@"d:\site\file\my.txt"))       //如果文件存則為真，不存在為假

           {

               File.Delete(@"d:\site\file\my.txt");   

               File.Create(@"d:\site\file\my.txt").Close();//文件如存在，就先刪掉此文件，馬上再建一個，建好后馬上關閉。

           }

            else

            {

                File.Create(@"d:\site\file\my.txt").Close();//如果文件不存在就直接建一個。

            }

string test= File.ReadAllText(@"d:\site\file\test.txt",Encoding.Default);

//讀取另一個文件中的內容，存為一個字符串。

          string[] test1 = File.ReadAllLines(@"d:\site\file\test.txt", Encoding.Default); //讀取另一個文件中的內容，存為一個字符串數組。

          File.AppendAllLines(path, test1);  //把字符串數組作為內容添加到path路徑所指文件中，即my.txt中。如此時把test1換成test會報錯，因為test只是一個字符串，不是一個數組.

          File.AppendAllText(path, test);    //把字符串添加到my.txt中。

          File.AppendAllText(path, "我是一個北方的狼");

          string[] s = File.ReadAllLines(@"d:\site\file\my.txt");  //讀取my.txt中的內容，并賦值給一個字符串數組。

          foreach (var item in s) //遍歷字符串數組

          {

              all += item.ToString();  //把字符串數組拼接成一個字符串。

          }

          //File.WriteAllLines(@"d:\site\file\test1.txt",s);   //把字符串數組的內容寫入test1.txt中，原來的文件內容會被覆蓋。

          //File.WriteAllText(@"d:\site\file\test.txt","我會覆蓋你原來的內容");//把字符串的內容寫入test1.txt中，原來的文件內容會被覆蓋

           Console.WriteLine(all);

           Console.ReadKey();   

    }

• 目錄操作

1、path類（路徑的操作）

String str=@”d:\site\loready\p_w_picpath\3.jpg”;

Console.writeline(Path.GetFileName(str));   //獲取路徑中的文件名，顯示為3.jpg

Console.writeline(Path.GetFileNameWithoutExtension(str));//獲取文件名，但不包含拄展名，顯示為3。

Console.writeline(Path.GetExtension(str));  //獲取擴展名，顯示為jpg

Console.writeline(Path.GetDirectoryName(str)); //獲取文件夾的名稱，顯示為d:\site\loready\p_w_picpath

Console.writeline(Path.GetFullPath(str));   //獲取全目錄，即顯示為d:\site\loready\p_w_picpath\3.jpg

Console.writeline(Path.Combine(@”c:\a\”,”b.txt”));  //連接兩個字符串作為路徑，顯示為c:\a\b.txt

其他方法見MSDN。

2、目錄的操作

Directory類

Directory.Delete(@"d:\site\file\file_dir”) //刪除一個目錄

Directory.Move(@"d:\site\file\file_dir1",@"d:\site\file\file_dir");//移動一個目錄到另一個目錄，前面是源目錄，后面是目的目錄路徑

            if(Directory.Exists(@"d:\site\file\file_dir"))//判斷目錄是否存在

            {

               string[]s=Directory.GetFiles(@"d:\site\file\file_dir");

//getfiles是獲取目錄下的文件及路徑。

               for (inti = 0; i < s.Length; i++)

               {

                   dir += s[i];

                }

            }

            else

            {

               Directory.CreateDirectory(@"d:\site\file\file_dir");//創建一個目錄

            }

            Console.WriteLine(dir);

            Console.ReadKey();

要想復制目錄，思路是用遞歸的方法遍歷源目錄下的所有目錄及文件，把這些目錄和文件再復制到另一個地方。

• 文件流操作（用于操作大文件）

把大文件碎片化操作，一塊一塊操作，而FILE類，則是文件一次性操作。

1、  Filestream（操作字節的，任何文件都可以操作）

（1）讀取數據

FileStream fs=newFileStream(@"d:\site\file\test.txt",FileMode.OpenOrCreate, FileAccess.Read);//第一個參數是要操作文件的路徑；第二個參數是對文件的操作模式，是打開（Open），創建(Create)，還是追加(Append)，OpenOrCreate是如果文件不存在就創建并打開，如果文件存在就直接打開；第三個參數是對文件里的數據進行的操作，是讀(fileaccess.read)，還是寫(fileaccess.write)。

byte[] buffer=newbyte[1024*1024*1]；//建立一個字節數組，并指定一次性讀取文件的大小，這里為1M。

 int r=fs.Read(buffer, 0, buffer.Length);   //第一個參數是指把讀取到的內容存到buffer字節數組中，第二個參數是從哪里開始寫入數據，0即是開始位置，buffer.length即表示每次最多讀取數據的大小，即1M。返回的int類型值，是指讀取到的字節數。

string s = Encoding.Default.GetString(buffer,0,r);  //把存放在字節數組中的數據流解碼成字符串。0是從流的0位置開始解碼，r是指解碼的字節數。這樣就會只解碼剛才讀的部分。

fs.Close();    //c#無法自動釋放數據流，所以要先關閉數據流，再用dispose（）釋放流。

 fs.Dispose();

 Console.WriteLine(s);

（2）寫入數據

using (FileStream fswrite = newFileStream(@"d:\site\file\test.txt", FileMode.OpenOrCreate, FileAccess.Write))   //using中會自動釋放流的資源。此處最后一個參數改成了寫的狀態。

   {

   string w = "我們的家在松花家上啊，那里有大豆高粱";

   byte[] buffer1 = Encoding.Default.GetBytes(w);    //把要寫入的字符先轉換成數據流，然后存入buffer1字節數組中。

  fswrite.Write(buffer1,0,buffer1.Length);           //第一個參數是字符數組，第二個參數是從哪里寫入，第三個參數是寫入的最大長度。

    Console.WriteLine("寫入OK");

Console.ReadKey();

2、  streamreader和streamwriter(操作字符的,即文本文件)

每次只讀文本中的一行，要讀完就要循環到文本的最后一行。

讀：

Using(streamreader sr=new streamreader(@”d:\site\file\test.txt”,encoding.default)

{

While(!sr.endofstream)  //如果沒讀到文本的行尾

{

Console.writeline(sr.readline());  //就不停的讀下一行并顯示出來。

}

}

寫：

Using(streamwriter sw=new streamwrite(@”d:\site\file\test.txt”,true)  //true表示追加到原文本后面，不會覆蓋原文本。

{

Sw.write(“要寫入的字符”);

}

第三部分：字符串操作、編碼及正則表達式

一、字符串操作

字符串是引用類型且字符串對象是不可變的：即它們創建之后就無法更改，不能依據其堆中的存儲地址找到它然后更改它。

如：string s=”123”;此時s在棧中指向堆中123的地址空間。

string s=”456”；此時對S重新賦值，但不會像其他類型一樣，456會存到123原有的地址空間，替換掉123，而是在堆中重新開辟一個空間存值 456，且把s在棧中指向的地址改向456的地址。原來123在堆中仍然存在，并沒有消失。

示例：

字符串的下標索引位是從0位開始。

String s=”abc_def”  //聲明字符串

String b=”efg”

1、  計算字符串

s.Length  //字符串長度,返回的是整數。

2、  截取字符串

s.Substring(start，end) //從字符串的第幾位到開始到第幾位結束間的所有字符串，可以只有start或只有end。從0位開始計算。

Cosole.writeline(s.substring(1，5)); //顯示結果為：bc_de

3、  分割字符串

s.Split(“分隔符”)//用分隔符把字符串分成多個字符串，返回字符串數組

string[] test=s.split(‘_’);   //把s字符串用_分成兩個字符串，即字符串組，注意是單引號。

console.writeline(test[0]); //顯示為abc

console.writeline(test[1]); //顯示為def

4、  替換字符串

s.replace(“source_string”,”replace_string”) //用后面的字符串替換掉前面的字符串。

    console.writeline(“abc”,”ABC”);  //顯示為ABC_def 

5、  比較字符串

s.Equals(b)  //比較兩個字符串是否相同，如果相同則返回ture，否則返回false。S字符串和b字符串不一樣，所以返回值為ture。

6、  轉換字符串

s.ToLower()  //把字符串轉換成小寫

s.ToUpper()  //把字符串轉換成大寫

7、  插入和刪除字符串

(1)s.Insert(start，”要插入的字符串”);  //從第幾位開始把后面的字符串插入到字符串中。

(2)s.Remove(start,end) //刪除字符串中從start位開始到end位結束的字符。可以只有start或只有end。

console.writeline(s.insert(4,b);  //顯示為 abc_efgdef ，從第四位開始插入字符串b變量中的內容。

8、  匹配索引和包含判斷

s.IndexOf(“bc”)// 從字符串頭部開始搜索第一個匹配“bc”的在字符串中的位置索引。如果沒有匹配，輸出為-1。此如出顯示出來，索引值為1,bc的開始下標為1開始。

s.Lastindexof(“de”)//從字符串尾部開始搜索第一個匹配“de”的位置索引。此處如顯示出來，索引值為4。

s.Contains("def")//判斷字符串中是否包含字符串"def"，有輸出ture,沒有輸出false.此處返回為ture。

9、  連接字符串

string[] arr = s.Split(‘_’);   //把字符串s用下劃線分隔成兩個字符串。這里是單引號。

此時arr[0]=”abc”;

   Arr[1]=”def”;

（1）      String.Join(“分隔符”,字符串數組名)  //把一個字符串數組連成一個字符串，用分隔符隔開。

Join(“分隔符”,字符串,字符串，字符串……) //把字符串連接成一個字符串，用分隔符隔開。

（2）String.Concat(字符串數組名)   //把字符串數組，連成一個字符串。 

String.Concat（字符串，字符串,…..） //把字符串連成一個字符串。

例：

String s=”abc_def”

string[]arr = s.Split('_'); //分割成兩個字符串

            stringtest=string.Join(",",arr);//用分隔符逗號把arr字符串數組中的字符串連接到一起。

Console.WriteLine(test); //顯示為abc,def

            Console.WriteLine(string.Concat("qf","ef",”mf”));//顯示為gfefmf

             Console.ReadKey();

Join和concat的區別，只是一個有分隔符，一個沒有。

（3）      StringBuilder類

StringBuilder sb =newStringBuilder(); //定義一個類對象。

sb.Append(s);   //把字符串變量s中的內容添加到sb對象中。

sb.Append(b);  //把字符串變量b中的內容添加到sb對象中。

Console.writeline(sb.tostring()); //再把sb對象轉換成字符串輸出顯示為abc_defefg

二、字符編碼

編碼：將字符串用怎樣的形式保存為二進制。

Asc: 128  主要是美國用，英文和數字。

Ascii: 256  歐州用

Gb2312   國標，中國用,簡體字

Big5      繁體字

Unicode   很全，世界上的編碼都包含，全世界都能用，但太大了，會慢。

Utf-8      世界通用，主要用于web。