c#學習筆記

時間 2019-11-21

標籤 c# 學習筆記欄目 C# 简体版

原文原文鏈接

一、程序結構javascript

using System;
namespace HelloWorldApplication
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
         /* 個人第一個 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

　　程序的第一行 using System; - using 關鍵字用於在程序中包含 System 命名空間。一個程序通常有多個 using 語句。
下一行是 namespace 聲明。一個 namespace 裏包含了一系列的類。HelloWorldApplication 命名空間包含了類 HelloWorld。
下一行是 class 聲明。類 HelloWorld 包含了程序使用的數據和方法聲明。類通常包含多個方法。方法定義了類的行爲。在這裏，HelloWorld類只有一個 Main 方法。
下一行定義了 Main 方法，是全部 C# 程序的 入口點。Main 方法說明當執行時類將作什麼動做。
下一行 /*...*/ 將會被編譯器忽略，且它會在程序中添加額外的註釋。
Main 方法經過語句 Console.WriteLine("Hello World"); 指定了它的行爲。
WriteLine 是一個定義在 System 命名空間中的 Console 類的一個方法。該語句會在屏幕上顯示消息 "Hello, World!"。java
最後一行 Console.ReadKey(); 是針對 VS.NET 用戶的。這使得程序會等待一個按鍵的動做，防止程序從 Visual Studio .NET 啓動時屏幕會快速運行並關閉。

二、標識符

標識符是用來識別類、變量、函數或任何其它用戶定義的項目。在 C# 中，類的命名必須遵循以下基本規則：程序員

標識符必須以字母、下劃線或 @ 開頭，後面能夠跟一系列的字母、數字（ 0 - 9 ）、下劃線（ _ ）、@。
標識符中的第一個字符不能是數字。
標識符必須不包含任何嵌入的空格或符號，好比 ? - +! # % ^ & * ( ) [ ] { } . ; : " ' / \。
標識符不能是 C# 關鍵字。除非它們有一個 @ 前綴。例如，@if 是有效的標識符，但 if 不是，由於 if 是關鍵字。
標識符必須區分大小寫。大寫字母和小寫字母被認爲是不一樣的字母。
不能與C#的類庫名稱相同。

三、數據類型

a、值類型（Value types）

值類型直接包含數據。好比 int、char、float，它們分別存儲數字、字符、浮點數。c#

下表列出了 C# 2010 中可用的值類型：數組

類型	描述	範圍	默認值
bool	布爾值	True 或 False	False
byte	8 位無符號整數	0 到 255	0
char	16 位 Unicode 字符	U +0000 到 U +ffff	'\0'
decimal	128 位精確的十進制值，28-29 有效位數	(-7.9 x 10²⁸ 到 7.9 x 10²⁸) / 10^{0 到 28}	0.0M
double	64 位雙精度浮點型	(+/-)5.0 x 10^-324 到 (+/-)1.7 x 10³⁰⁸	0.0D
float	32 位單精度浮點型	-3.4 x 10³⁸ 到 + 3.4 x 10³⁸	0.0F
int	32 位有符號整數類型	-2,147,483,648 到 2,147,483,647	0
long	64 位有符號整數類型	-923,372,036,854,775,808 到 9,223,372,036,854,775,807	0L
sbyte	8 位有符號整數類型	-128 到 127	0
short	16 位有符號整數類型	-32,768 到 32,767	0
uint	32 位無符號整數類型	0 到 4,294,967,295	0
ulong	64 位無符號整數類型	0 到 18,446,744,073,709,551,615	0
ushort	16 位無符號整數類型	0 到 65,535	0

如需獲得一個類型或一個變量在特定平臺上的準確尺寸，可使用 sizeof 方法。表達式 sizeof(type) 產生以字節爲單位存儲對象或類型的存儲尺寸。安全

b、引用類型（Reference types）

引用類型不包含存儲在變量中的實際數據，但它們包含對變量的引用。它們指的是一個內存位置。使用多個變量時，引用類型能夠指向一個內存位置。若是內存位置的數據是由一個變量改變的，其餘變量會自動反映這種值的變化。內置的 引用類型有：object、dynamic 和 string。數據結構

對象類型：對象（Object）類型能夠被分配任何其餘類型（值類型、引用類型、預約義類型或用戶自定義類型）的值。可是，在分配值以前，須要先進行類型轉換。app

　　當一個值類型轉換爲對象類型時，則被稱爲裝箱；另外一方面，當一個對象類型轉換爲值類型時，則被稱爲拆箱。ide

object obj;
obj = 100; // 這是裝箱

c、動態（Dynamic）類型

能夠存儲任何類型的值在動態數據類型變量中。這些變量的類型檢查是在運行時發生的。函數

dynamic d = 20;

　　動態類型與對象類型類似，可是對象類型變量的類型檢查是在編譯時發生的，而動態類型變量的類型檢查是在運行時發生的。

d、字符串（String）類型

字符串（String）類型 容許您給變量分配任何字符串值。字符串（String）類型是 System.String 類的別名。它是從對象（Object）類型派生的。字符串（String）類型的值能夠經過兩種形式進行分配：引號和 @引號。

String str = "runoob.com";
或：
@"runoob.com";
C# string 字符串的前面能夠加 @（稱做"逐字字符串"）將轉義字符（\）看成普通字符對待，好比：
string str = @"C:\Windows";
等價於：
string str = "C:\\Windows";
@ 字符串中能夠任意換行，換行符及縮進空格都計算在字符串長度以內。
string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";

e、指針類型（Pointer types）

type* identifier;

四、類型轉換

c#中，類型轉換（或者叫作類型鑄造）有兩種形式：

隱式類型轉換 - 這些轉換是 C# 默認的以安全方式進行的轉換, 不會致使數據丟失。例如，從小的整數類型轉換爲大的整數類型，從派生類轉換爲基類。
顯式類型轉換 - 顯式類型轉換，即強制類型轉換。顯式轉換須要強制轉換運算符，並且強制轉換會形成數據丟失。

namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;

            // 強制轉換 double 爲 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
            
        }
    }
}

C# 提供了下列內置的類型轉換方法：

序號	方法 & 描述
1	ToBoolean 若是可能的話，把類型轉換爲布爾型。
2	ToByte 把類型轉換爲字節類型。
3	ToChar 若是可能的話，把類型轉換爲單個 Unicode 字符類型。
4	ToDateTime 把類型（整數或字符串類型）轉換爲日期-時間結構。
5	ToDecimal 把浮點型或整數類型轉換爲十進制類型。
6	ToDouble 把類型轉換爲雙精度浮點型。
7	ToInt16 把類型轉換爲 16 位整數類型。
8	ToInt32 把類型轉換爲 32 位整數類型。
9	ToInt64 把類型轉換爲 64 位整數類型。
10	ToSbyte 把類型轉換爲有符號字節類型。
11	ToSingle 把類型轉換爲小浮點數類型。
12	ToString 把類型轉換爲字符串類型。
13	ToType 把類型轉換爲指定類型。
14	ToUInt16 把類型轉換爲 16 位無符號整數類型。
15	ToUInt32 把類型轉換爲 32 位無符號整數類型。
16	ToUInt64 把類型轉換爲 64 位無符號整數類型。

下面的實例把不一樣值的類型轉換爲字符串類型：

namespace TypeConversionApplication
{
    class StringConversion
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;

            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());
            Console.ReadKey();
        }
    }
}

五、變量

C# 中變量定義的語法：

<data_type> <variable_list>;

data_type 必須是一個有效的 C# 數據類型，能夠是 char、int、float、double 或其餘用戶自定義的數據類型。variable_list 能夠由一個或多個用逗號分隔的標識符名稱組成。

System 命名空間中的 Console 類提供了一個函數 ReadLine()，用於接收來自用戶的輸入，並把它存儲到一個變量中。

int num;
num = Convert.ToInt32(Console.ReadLine());

函數 Convert.ToInt32() 把用戶輸入的數據轉換爲 int 數據類型，由於 Console.ReadLine() 只接受字符串格式的數據。

六、常量

常量是使用 const 關鍵字來定義的。

public const int c1 = 5;

a、整數常量：

整數常量能夠是十進制、八進制或十六進制的常量。前綴指定基數：0x 或 0X 表示十六進制，0 表示八進制，沒有前綴則表示十進制。整數常量也能夠有後綴，能夠是 U 和 L 的組合，其中，U 和 L 分別表示 unsigned 和 long。後綴能夠是大寫或者小寫，多個後綴以任意順序進行組合。

212         /* 合法 */
215u        /* 合法 */
0xFeeL      /* 合法 */
078         /* 非法：8 不是一個八進制數字 */
032UU       /* 非法：不能重複後綴 */

　　如下是各類類型的整數常量的實例：

85         /* 十進制 */
0213       /* 八進制 */
0x4b       /* 十六進制 */
30         /* int */
30u        /* 無符號 int */
30l        /* long */
30ul       /* 無符號 long */

b、浮點常量：

個浮點常量是由整數部分、小數點、小數部分和指數部分組成。您可使用小數形式或者指數形式來表示浮點常量。使用小數形式表示時，必須包含小數點、指數或同時包含二者。使用指數形式表示時，必須包含整數部分、小數部分或同時包含二者。有符號的指數是用 e 或 E 表示的。

3.14159       /* 合法 */
314159E-5L    /* 合法 */
510E          /* 非法：不徹底指數 */
210f          /* 非法：沒有小數或指數 */
.e55          /* 非法：缺乏整數或小數 */

c、字符常量

字符常量是括在單引號裏，例如，'x'，且可存儲在一個簡單的字符類型變量中。一個字符常量能夠是一個普通字符（例如 'x'）、一個轉義序列（例如 '\t'）或者一個通用字符（例如 '\u02C0'）。

在 C# 中有一些特定的字符，當它們的前面帶有反斜槓時有特殊的意義，可用於表示換行符（\n）或製表符 tab（\t）。

轉義序列	含義
\\	\ 字符
\'	' 字符
\"	" 字符
\?	? 字符
\a	Alert 或 bell
\b	退格鍵（Backspace）
\f	換頁符（Form feed）
\n	換行符（Newline）
\r	回車
\t	水平製表符 tab
\v	垂直製表符 tab
\ooo	一到三位的八進制數
\xhh . . .	一個或多個數字的十六進制數

d、字符串常量

string c = "hello \t world";               // hello     world
string d = @"hello \t world";               // hello \t world
string e = "Joe said \"Hello\" to me";      // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me";   // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt";   // \\server\share\file.txt
string h = @"\\server\share\file.txt";      // \\server\share\file.txt

七、封裝

封裝被定義爲"把一個或多個項目封閉在一個物理的或者邏輯的包中"。在面向對象程序設計方法論中，封裝是爲了防止對實現細節的訪問。

C# 封裝根據具體的須要，設置使用者的訪問權限，並經過 訪問修飾符 來實現。一個 訪問修飾符 定義了一個類成員的範圍和可見性。C# 支持的訪問修飾符以下所示：

public：全部對象均可以訪問；
private：對象自己在對象內部能夠訪問；
protected：只有該類對象及其子類對象能夠訪問
internal：同一個程序集的對象能夠訪問；
protected internal：訪問限於當前程序集或派生自包含類的類型。

若是沒有指定訪問修飾符，則使用類成員的默認訪問修飾符，即爲 private。

八、方法

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

Access Specifier：訪問修飾符，這個決定了變量或方法對於另外一個類的可見性。
Return type：返回類型，一個方法能夠返回一個值。返回類型是方法返回的值的數據類型。若是方法不返回任何值，則返回類型爲 void。
Method name：方法名稱，是一個惟一的標識符，且是大小寫敏感的。它不能與類中聲明的其餘標識符相同。
Parameter list：參數列表，使用圓括號括起來，該參數是用來傳遞和接收方法的數據。參數列表是指方法的參數類型、順序和數量。參數是可選的，也就是說，一個方法可能不包含參數。
Method body：方法主體，包含了完成任務所需的指令集。

方法調用的時候有三種傳遞參數的方法：值參數、引用參數、輸出參數；

a、值參數

普通的方法調用便是用的這種參數，實際參數的值會複製給形參，實參和形參使用的是兩個不一樣內存中的值。因此，當形參的值發生改變時，不會影響實參的值，從而保證了實參數據的安全。

b、引用參數

引用參數表示與提供給方法的實際參數具備相同的內存位置。因此當方法內的形參發生改變時，調用方法時傳遞的實參也會發生變化；

......
public void swap(ref int x, ref int y)
......
/* 調用函數來交換值 */
n.swap(ref a, ref b);
......

在c#中，這種參數使用的時候在形參和實參前加上ref關鍵字

c、按輸出傳遞參數

輸出參數會把方法輸出的數據賦給本身，其餘方面與引用參數類似。

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValues(out int x, out int y )
      {
          Console.WriteLine("請輸入第一個值： ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("請輸入第二個值： ");
          y = Convert.ToInt32(Console.ReadLine());
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部變量定義 */
         int a , b;
         
         /* 調用函數來獲取值 */
         n.getValues(out a, out b);

         Console.WriteLine("在方法調用以後，a 的值： {0}", a);
         Console.WriteLine("在方法調用以後，b 的值： {0}", b);
         Console.ReadLine();
      }
   }
}

當須要從一個參數沒有指定初始值的方法中返回值時，輸出參數特別有用。上例中若是改成引用參數因爲沒有給參數制定初始值，會出現報錯。

九、可空類型

C# 提供了一個特殊的數據類型，nullable 類型（可空類型），用於對 int,double,bool 等沒法直接賦值爲 null 的數據類型進行 null 的賦值，可空類型能夠表示其基礎值類型正常範圍內的值，再加上一個 null 值。

例如，Nullable< Int32 >，讀做"可空的 Int32"，能夠被賦值爲 -2,147,483,648 到 2,147,483,647 之間的任意值，也能夠被賦值爲 null 值。相似的，Nullable< bool > 變量能夠被賦值爲 true 或 false 或 null。

         int? num1 = null;
         int? num2 = 45;
         double? num3 = new double?();
         double? num4 = 3.14157;
         bool? boolval = new bool?();

Null 合併運算符

Null 合併運算符把操做數類型隱式轉換爲另外一個可空（或不可空）的值類型的操做數的類型。若是第一個操做數的值爲 null，則運算符返回第二個操做數的值，不然返回第一個操做數的值。

double? num1 = null;
double? num2 = 3.14157;
double num3;
num3 = num1 ?? 5.34;      // num1 若是爲空值則返回 5.34
Console.WriteLine("num3 的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);

十、數組

double[] balance = new double[10];

賦值：能夠經過使用索引號賦值給一個單獨的數組元素：

double[] balance = new double[10];
balance[0] = 4500.0;

能夠在聲明數組的同時給數組賦值：

double[] balance = { 2340.0, 4523.69, 3421.0};

也能夠建立並初始化一個數組：

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

能夠省略數組的大小：

int [] marks = new int[]  { 99,  98, 92, 97, 95};

建立一個數組時，C# 編譯器會根據數組類型隱式初始化每一個數組元素爲一個默認值。例如，int 數組的全部元素都會被初始化爲 0。

建立一個二維數組：

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引號爲 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引號爲 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引號爲 2 的行 */
};

建立的時候用逗號隔開，同理能夠建立多維數組。

交錯數組

交錯數組是數組的數組。

/* 一個由 5 個整型數組組成的交錯數組 */
int[][] a = new int[][]{new int[]{0,0},new int[]{1,2}, 
new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } };

參數數組

有時，當聲明一個方法時，您不能肯定要傳遞給函數做爲參數的參數數目。C# 參數數組解決了這個問題，參數數組一般用於傳遞未知數量的參數給函數（相似於js中的argument）。

......
public int AddElements(params int[] arr)
{
    int sum = 0;
    foreach (int i in arr)
    {
        sum += i;
     }
     return sum;
}
......
int sum = app.AddElements(512, 720, 250, 567, 889);
......

Array 類

Array 類是 C# 中全部數組的基類，它是在 System 命名空間中定義。Array 類提供了各類用於數組的屬性和方法。

序號	屬性 & 描述
1	IsFixedSize 獲取一個值，該值指示數組是否帶有固定大小。
2	IsReadOnly 獲取一個值，該值指示數組是否只讀。
3	Length 獲取一個 32 位整數，該值表示全部維度的數組中的元素總數。
4	LongLength 獲取一個 64 位整數，該值表示全部維度的數組中的元素總數。
5	Rank 獲取數組的秩（維度）。

Array的一些經常使用方法：

序號	方法 & 描述
1	Clear 根據元素的類型，設置數組中某個範圍的元素爲零、爲 false 或者爲 null。
2	Copy(Array, Array, Int32) 從數組的第一個元素開始複製某個範圍的元素到另外一個數組的第一個元素位置。長度由一個 32 位整數指定。
3	CopyTo(Array, Int32) 從當前的一維數組中複製全部的元素到一個指定的一維數組的指定索引位置。索引由一個 32 位整數指定。
4	GetLength 獲取一個 32 位整數，該值表示指定維度的數組中的元素總數。
5	GetLongLength 獲取一個 64 位整數，該值表示指定維度的數組中的元素總數。
6	GetLowerBound 獲取數組中指定維度的下界。
7	GetType 獲取當前實例的類型。從對象（Object）繼承。
8	GetUpperBound 獲取數組中指定維度的上界。
9	GetValue(Int32) 獲取一維數組中指定位置的值。索引由一個 32 位整數指定。
10	IndexOf(Array, Object) 搜索指定的對象，返回整個一維數組中第一次出現的索引。
11	Reverse(Array) 逆轉整個一維數組中元素的順序。
12	SetValue(Object, Int32) 給一維數組中指定位置的元素設置值。索引由一個 32 位整數指定。
13	Sort(Array) 使用數組的每一個元素的 IComparable 實現來排序整個一維數組中的元素。
14	ToString 返回一個表示當前對象的字符串。從對象（Object）繼承。

如需瞭解 Array 類的完整的方法列表，請參閱微軟的 C# 文檔。

int[] list = { 34, 72, 13, 44, 25, 30, 10 };

            Console.Write("原始數組： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           
            // 逆轉數組
            Array.Reverse(list);
            Console.Write("逆轉數組： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            
            // 排序數組
            Array.Sort(list);
            Console.Write("排序數組： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

十一、字符串

//字符串，字符串鏈接
            string fname, lname;
            fname = "Rowan";
            lname = "Atkinson";

            string fullname = fname + lname;
            Console.WriteLine("Full Name: {0}", fullname);

            //經過使用 string 構造函數
            char[] letters = { 'H', 'e', 'l', 'l','o' };
            string greetings = new string(letters);
            Console.WriteLine("Greetings: {0}", greetings);

            //方法返回字符串
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };
            string message = String.Join(" ", sarray);
            Console.WriteLine("Message: {0}", message);

            //用於轉化值的格式化方法
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
            string chat = String.Format("Message sent at {0:t} on {0:D}", 
            waiting);
            Console.WriteLine("Message: {0}", chat);
            Console.ReadKey() ;

String 類有許多方法用於 string 對象的操做。下面的表格提供了一些最經常使用的方法：

序號	方法名稱 & 描述
1	public static int Compare( string strA, string strB ) 比較兩個指定的 string 對象，並返回一個表示它們在排列順序中相對位置的整數。該方法區分大小寫。
2	public static int Compare( string strA, string strB, bool ignoreCase ) 比較兩個指定的 string 對象，並返回一個表示它們在排列順序中相對位置的整數。可是，若是布爾參數爲真時，該方法不區分大小寫。
3	public static string Concat( string str0, string str1 ) 鏈接兩個 string 對象。
4	public static string Concat( string str0, string str1, string str2 ) 鏈接三個 string 對象。
5	public static string Concat( string str0, string str1, string str2, string str3 ) 鏈接四個 string 對象。
6	public bool Contains( string value ) 返回一個表示指定 string 對象是否出如今字符串中的值。
7	public static string Copy( string str ) 建立一個與指定字符串具備相同值的新的 String 對象。
8	public void CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count ) 從 string 對象的指定位置開始複製指定數量的字符到 Unicode 字符數組中的指定位置。
9	public bool EndsWith( string value ) 判斷 string 對象的結尾是否匹配指定的字符串。
10	public bool Equals( string value ) 判斷當前的 string 對象是否與指定的 string 對象具備相同的值。
11	public static bool Equals( string a, string b ) 判斷兩個指定的 string 對象是否具備相同的值。
12	public static string Format( string format, Object arg0 ) 把指定字符串中一個或多個格式項替換爲指定對象的字符串表示形式。
13	public int IndexOf( char value ) 返回指定 Unicode 字符在當前字符串中第一次出現的索引，索引從 0 開始。
14	public int IndexOf( string value ) 返回指定字符串在該實例中第一次出現的索引，索引從 0 開始。
15	public int IndexOf( char value, int startIndex ) 返回指定 Unicode 字符從該字符串中指定字符位置開始搜索第一次出現的索引，索引從 0 開始。
16	public int IndexOf( string value, int startIndex ) 返回指定字符串從該實例中指定字符位置開始搜索第一次出現的索引，索引從 0 開始。
17	public int IndexOfAny( char[] anyOf ) 返回某一個指定的 Unicode 字符數組中任意字符在該實例中第一次出現的索引，索引從 0 開始。
18	public int IndexOfAny( char[] anyOf, int startIndex ) 返回某一個指定的 Unicode 字符數組中任意字符從該實例中指定字符位置開始搜索第一次出現的索引，索引從 0 開始。
19	public string Insert( int startIndex, string value ) 返回一個新的字符串，其中，指定的字符串被插入在當前 string 對象的指定索引位置。
20	public static bool IsNullOrEmpty( string value ) 指示指定的字符串是否爲 null 或者是否爲一個空的字符串。
21	public static string Join( string separator, string[] value ) 鏈接一個字符串數組中的全部元素，使用指定的分隔符分隔每一個元素。
22	public static string Join( string separator, string[] value, int startIndex, int count ) 鏈接接一個字符串數組中的指定位置開始的指定元素，使用指定的分隔符分隔每一個元素。
23	public int LastIndexOf( char value ) 返回指定 Unicode 字符在當前 string 對象中最後一次出現的索引位置，索引從 0 開始。
24	public int LastIndexOf( string value ) 返回指定字符串在當前 string 對象中最後一次出現的索引位置，索引從 0 開始。
25	public string Remove( int startIndex ) 移除當前實例中的全部字符，從指定位置開始，一直到最後一個位置爲止，並返回字符串。
26	public string Remove( int startIndex, int count ) 從當前字符串的指定位置開始移除指定數量的字符，並返回字符串。
27	public string Replace( char oldChar, char newChar ) 把當前 string 對象中，全部指定的 Unicode 字符替換爲另外一個指定的 Unicode 字符，並返回新的字符串。
28	public string Replace( string oldValue, string newValue ) 把當前 string 對象中，全部指定的字符串替換爲另外一個指定的字符串，並返回新的字符串。
29	public string[] Split( params char[] separator ) 返回一個字符串數組，包含當前的 string 對象中的子字符串，子字符串是使用指定的 Unicode 字符數組中的元素進行分隔的。
30	public string[] Split( char[] separator, int count ) 返回一個字符串數組，包含當前的 string 對象中的子字符串，子字符串是使用指定的 Unicode 字符數組中的元素進行分隔的。int 參數指定要返回的子字符串的最大數目。
31	public bool StartsWith( string value ) 判斷字符串實例的開頭是否匹配指定的字符串。
32	public char[] ToCharArray() 返回一個帶有當前 string 對象中全部字符的 Unicode 字符數組。
33	public char[] ToCharArray( int startIndex, int length ) 返回一個帶有當前 string 對象中全部字符的 Unicode 字符數組，從指定的索引開始，直到指定的長度爲止。
34	public string ToLower() 把字符串轉換爲小寫並返回。
35	public string ToUpper() 把字符串轉換爲大寫並返回。
36	public string Trim() 移除當前 String 對象中的全部前導空白字符和後置空白字符。

......
if (String.Compare(str1, str2) == 0)
......

十二、結構體

結構體是值類型數據結構。它使得一個單一變量能夠存儲各類數據類型的相關數據。struct 關鍵字用於建立結構體。結構體是用來表明一個記錄。

using System;
using System.Text;
     
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void getValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id; 
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1 = new Books(); /* 聲明 Book1，類型爲 Book */
      Books Book2 = new Books(); /* 聲明 Book2，類型爲 Book */

      /* book 1 詳述 */
      Book1.getValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* book 2 詳述 */
      Book2.getValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

      /* 打印 Book1 信息 */
      Book1.display();

      /* 打印 Book2 信息 */
      Book2.display(); 

      Console.ReadKey();

   }
}

結構體和類的不一樣：

類是引用類型，結構是值類型。
結構不支持繼承。
結構不能聲明默認的構造函數。

1三、類

構造函數

類的 構造函數 是類的一個特殊的成員函數，當建立類的新對象時執行。構造函數的名稱與類的名稱徹底相同，它沒有任何返回類型。

默認的構造函數沒有任何參數。可是若是你須要一個帶有參數的構造函數能夠有參數，這種構造函數叫作參數化構造函數。

class Line
   {
      private double length;   // 線條的長度
      public Line(double len)  // 參數化構造函數
      {
         Console.WriteLine("對象已建立，length = {0}", len);
         length = len;
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line(10.0);
         Console.WriteLine("線條的長度： {0}", line.getLength()); 
         // 設置線條長度
         line.setLength(6.0);
         Console.WriteLine("線條的長度： {0}", line.getLength()); 
         Console.ReadKey();
      }
   }

折構函數

類的 析構函數 是類的一個特殊的成員函數，當類的對象超出範圍時執行。

析構函數的名稱是在類的名稱前加上一個波浪形（~）做爲前綴，它不返回值，也不帶任何參數。

析構函數用於在結束程序（好比關閉文件、釋放內存等）以前釋放資源。析構函數不能繼承或重載。

class Line
   {
      private double length;   // 線條的長度
      public Line()  // 構造函數
      {
         Console.WriteLine("對象已建立");
      }
      ~Line() //析構函數
      {
         Console.WriteLine("對象已刪除");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();
         // 設置線條長度
         line.setLength(6.0);
         Console.WriteLine("線條的長度： {0}", line.getLength());           
      }
   }

靜態成員

咱們可使用 static 關鍵字把類成員定義爲靜態的。當咱們聲明一個類成員爲靜態時，意味着不管有多少個類的對象被建立，只會有一個該靜態成員的副本。

關鍵字 static 意味着類中只有一個該成員的實例。靜態變量用於定義常量，由於它們的值能夠經過直接調用類而不須要建立類的實例來獲取。靜態變量可在成員函數或類的定義外部進行初始化。你也能夠在類的定義內部初始化靜態變量。

class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s1 = new StaticVar();
            StaticVar s2 = new StaticVar();
            s1.count();
            s1.count();
            s1.count();
            s2.count();
            s2.count();
            s2.count();         
            Console.WriteLine("s1 的變量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的變量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }

　　在上面這個例子中，num被定義成一個靜態成員，因此無論後續該類被調用幾回，該成員只使用這一個副本。num初始值爲0，在Main中被s1和s2一共累加6次，因此最後結果s1和s2的輸出都是6。

1四、繼承

當建立一個類時，不須要徹底從新編寫新的數據成員和成員函數，只須要設計一個新的類，繼承了已有的類的成員便可。這個已有的類被稱爲的基類，這個新的類被稱爲派生類。

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成員變量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("長度： {0}", length);
         Console.WriteLine("寬度： {0}", width);
         Console.WriteLine("面積： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

若是派生類和基類中存在相同命名的成員，那麼在派生類中要經過base來調用基類中的成員

C# 不支持多重繼承。可是，可使用接口來實現多重繼承。

1五、重載

重載是能夠在同一個範圍內對相同的函數名有多個定義。函數的定義必須彼此不一樣，能夠是參數列表中的參數類型不一樣，也能夠是參數個數不一樣。不能重載只有返回類型不一樣的函數聲明。

void print(int i)
      {
         Console.WriteLine("Printing int: {0}", i );
      }

      void print(double f)
      {
         Console.WriteLine("Printing float: {0}" , f);
      }

      void print(string s)
      {
         Console.WriteLine("Printing string: {0}", s);
      }
      static void Main(string[] args)
      {
         Printdata p = new Printdata();
         // 調用 print 來打印整數
         p.print(5);
         // 調用 print 來打印浮點數
         p.print(500.263);
         // 調用 print 來打印字符串
         p.print("Hello C++");
         Console.ReadKey();
      }

1六、命名空間

命名空間的設計目的是提供一種讓一組名稱與其餘名稱分隔開的方式。在一個命名空間中聲明的類的名稱與另外一個命名空間中聲明的相同的類的名稱不衝突。

namespace_name.item_name;

前面的是名空間的名稱，點後面的是支持命名空間版本的函數或變量（類名）。

using 關鍵字

using 關鍵字代表程序使用的是給定命名空間中的名稱。也可使用 using 命名空間指令，這樣在使用的時候就不用在前面加上命名空間名稱。該指令告訴編譯器隨後的代碼使用了指定命名空間中的名稱。

using System;
using first_space;
using second_space;

namespace first_space
{
   class abc
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space
{
   class efg
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}   
class TestClass
{
   static void Main(string[] args)
   {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

可使用點（.）運算符訪問嵌套的命名空間的成員

using SomeNameSpace.Nested;

1七、預處理指令

預處理器指令指導編譯器在實際編譯開始以前對信息進行預處理。

預處理器指令	描述
#define	它用於定義一系列成爲符號的字符。
#undef	它用於取消定義符號。
#if	它用於測試符號是否爲真。
#else	它用於建立複合條件指令，與 #if 一塊兒使用。
#elif	它用於建立複合條件指令。
#endif	指定一個條件指令的結束。
#line	它可讓您修改編譯器的行數以及（可選地）輸出錯誤和警告的文件名。
#error	它容許從代碼的指定位置生成一個錯誤。
#warning	它容許從代碼的指定位置生成一級警告。
#region	它可讓您在使用 Visual Studio Code Editor 的大綱特性時，指定一個可展開或摺疊的代碼塊。
#endregion	它標識着 #region 塊的結束。

#define 容許您定義一個符號，這樣，經過使用符號做爲傳遞給 #if 指令的表達式，表達式將返回 true。

#define PI 
using System;
namespace PreprocessorDAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         #if (PI)
            Console.WriteLine("PI is defined");
         #else
            Console.WriteLine("PI is not defined");
         #endif
         Console.ReadKey();
      }
   }
}

一個以 #if 指令開始的條件指令，必須顯示地以一個 #endif 指令終止。

預處理器指令的用途理解：

在程序調試和運行上有重要的做用。好比預處理器指令能夠禁止編譯器編譯代碼的某一部分，若是計劃發佈兩個版本的代碼，即基本版本和有更多功能的企業版本，就可使用這些預處理器指令來控制。在編譯軟件的基本版本時，使用預處理器指令還能夠禁止編譯器編譯於額外功能相關的代碼。另外，在編寫提供調試信息的代碼時，也可使用預處理器指令進行控制。總的來講和普通的控制語句（if等）功能相似，方便在於預處理器指令包含的未執行部分是不須要編譯的。

1八、異常處理

異常提供了一種把程序控制權從某個部分轉移到另外一個部分的方式。

try：一個 try 塊標識了一個將被激活的特定的異常的代碼塊。後跟一個或多個 catch 塊。
catch：程序經過異常處理程序捕獲異常。catch 關鍵字表示異常的捕獲。
finally：finally 塊用於執行給定的語句，無論異常是否被拋出都會執行。例如，若是您打開一個文件，無論是否出現異常文件都要被關閉。
throw：當問題出現時，程序拋出一個異常。使用 throw 關鍵字來完成。

異常類

C# 異常是使用類來表示的。C# 中的異常類主要是直接或間接地派生於 System.Exception 類。System.ApplicationException 和 System.SystemException 類是派生於 System.Exception 類的異常類。

System.ApplicationException 類支持由應用程序生成的異常。因此程序員定義的異常都應派生自該類。

System.SystemException 類是全部預約義的系統異常的基類。

異常類	描述
System.IO.IOException	處理 I/O 錯誤。
System.IndexOutOfRangeException	處理當方法指向超出範圍的數組索引時生成的錯誤。
System.ArrayTypeMismatchException	處理當數組類型不匹配時生成的錯誤。
System.NullReferenceException	處理當依從一個空對象時生成的錯誤。
System.DivideByZeroException	處理當除以零時生成的錯誤。
System.InvalidCastException	處理在類型轉換期間生成的錯誤。
System.OutOfMemoryException	處理空閒內存不足生成的錯誤。
System.StackOverflowException	處理棧溢出生成的錯誤。

異常處理

C# 以 try 和 catch 塊的形式提供了一種結構化的異常處理方案。使用這些塊，把核心程序語句與錯誤處理語句分離開。

這些錯誤處理塊是使用 try、catch 和 finally 關鍵字實現的。

1九、文件的輸入和輸出

一個文件是一個存儲在磁盤中帶有指定名稱和目錄路徑的數據集合。當打開文件進行讀寫時，它變成一個流。

從根本上說，流是經過通訊路徑傳遞的字節序列。有兩個主要的流：輸入流 和 輸出流。輸入流用於從文件讀取數據（讀操做），輸出流用於向文件寫入數據（寫操做）。

System.IO類

System.IO 命名空間有各類不一樣的類，用於執行各類文件操做，如建立和刪除文件、讀取或寫入文件，關閉文件等。

I/O 類	描述
BinaryReader	從二進制流讀取原始數據。
BinaryWriter	以二進制格式寫入原始數據。
BufferedStream	字節流的臨時存儲。
Directory	有助於操做目錄結構。
DirectoryInfo	用於對目錄執行操做。
DriveInfo	提供驅動器的信息。
File	有助於處理文件。
FileInfo	用於對文件執行操做。
FileStream	用於文件中任何位置的讀寫。
MemoryStream	用於隨機訪問存儲在內存中的數據流。
Path	對路徑信息執行操做。
StreamReader	用於從字節流中讀取字符。
StreamWriter	用於向一個流中寫入字符。
StringReader	用於讀取字符串緩衝區。
StringWriter	用於寫入字符串緩衝區。

FileStream 類

System.IO 命名空間中的 FileStream 類有助於文件的讀寫與關閉。該類派生自抽象類 Stream。

您須要建立一個 FileStream 對象來建立一個新的文件，或打開一個已有的文件。例如，建立一個 FileStream 對象 F 來讀取名爲 sample.txt 的文件：

FileStream F = new FileStream("sample.txt", FileMode.Open, FileAccess.Read, FileShare.Read);

參數	描述
FileMode	FileMode 枚舉定義了各類打開文件的方法。FileMode 枚舉的成員有： Append：打開一個已有的文件，並將光標放置在文件的末尾。若是文件不存在，則建立文件。 Create：建立一個新的文件。若是文件已存在，則刪除舊文件，而後建立新文件。 CreateNew：指定操做系統應建立一個新的文件。若是文件已存在，則拋出異常。 Open：打開一個已有的文件。若是文件不存在，則拋出異常。 OpenOrCreate：指定操做系統應打開一個已有的文件。若是文件不存在，則用指定的名稱建立一個新的文件打開。 Truncate：打開一個已有的文件，文件一旦打開，就將被截斷爲零字節大小。而後咱們能夠向文件寫入全新的數據，可是保留文件的初始建立日期。若是文件不存在，則拋出異常。
FileAccess	FileAccess 枚舉的成員有：Read、ReadWrite 和 Write。
FileShare	FileShare 枚舉的成員有： Inheritable：容許文件句柄可由子進程繼承。Win32 不直接支持此功能。 None：謝絕共享當前文件。文件關閉前，打開該文件的任何請求（由此進程或另外一進程發出的請求）都將失敗。 Read：容許隨後打開文件讀取。若是未指定此標誌，則文件關閉前，任何打開該文件以進行讀取的請求（由此進程或另外一進程發出的請求）都將失敗。可是，即便指定了此標誌，仍可能須要附加權限纔可以訪問該文件。 ReadWrite：容許隨後打開文件讀取或寫入。若是未指定此標誌，則文件關閉前，任何打開該文件以進行讀取或寫入的請求（由此進程或另外一進程發出）都將失敗。可是，即便指定了此標誌，仍可能須要附加權限纔可以訪問該文件。 Write：容許隨後打開文件寫入。若是未指定此標誌，則文件關閉前，任何打開該文件以進行寫入的請求（由此進程或另外一進過程發出的請求）都將失敗。可是，即便指定了此標誌，仍可能須要附加權限纔可以訪問該文件。 Delete：容許隨後刪除文件。

參數

描述

FileMode

FileMode 枚舉定義了各類打開文件的方法。FileMode 枚舉的成員有：

Append：打開一個已有的文件，並將光標放置在文件的末尾。若是文件不存在，則建立文件。
Create：建立一個新的文件。若是文件已存在，則刪除舊文件，而後建立新文件。
CreateNew：指定操做系統應建立一個新的文件。若是文件已存在，則拋出異常。
Open：打開一個已有的文件。若是文件不存在，則拋出異常。
OpenOrCreate：指定操做系統應打開一個已有的文件。若是文件不存在，則用指定的名稱建立一個新的文件打開。
Truncate：打開一個已有的文件，文件一旦打開，就將被截斷爲零字節大小。而後咱們能夠向文件寫入全新的數據，可是保留文件的初始建立日期。若是文件不存在，則拋出異常。

FileAccess

FileAccess 枚舉的成員有：Read、ReadWrite 和 Write。

FileShare

FileShare 枚舉的成員有：

Inheritable：容許文件句柄可由子進程繼承。Win32 不直接支持此功能。
None：謝絕共享當前文件。文件關閉前，打開該文件的任何請求（由此進程或另外一進程發出的請求）都將失敗。
Read：容許隨後打開文件讀取。若是未指定此標誌，則文件關閉前，任何打開該文件以進行讀取的請求（由此進程或另外一進程發出的請求）都將失敗。可是，即便指定了此標誌，仍可能須要附加權限纔可以訪問該文件。
ReadWrite：容許隨後打開文件讀取或寫入。若是未指定此標誌，則文件關閉前，任何打開該文件以進行讀取或寫入的請求（由此進程或另外一進程發出）都將失敗。可是，即便指定了此標誌，仍可能須要附加權限纔可以訪問該文件。
Write：容許隨後打開文件寫入。若是未指定此標誌，則文件關閉前，任何打開該文件以進行寫入的請求（由此進程或另外一進過程發出的請求）都將失敗。可是，即便指定了此標誌，仍可能須要附加權限纔可以訪問該文件。
Delete：容許隨後刪除文件。

class Program
    {
        static void Main(string[] args)
        {
            FileStream F = new FileStream("test.dat", 
            FileMode.OpenOrCreate, FileAccess.ReadWrite);

            for (int i = 1; i <= 20; i++)
            {
                F.WriteByte((byte)i);
            }

            F.Position = 0;

            for (int i = 0; i <= 20; i++)
            {
                Console.Write(F.ReadByte() + " ");
            }
            F.Close();
            Console.ReadKey();
        }
    }

20、文本文件的讀寫

StreamReader 類（表示閱讀器讀取一系列字符）

序號	方法 & 描述
1	public override void Close() 關閉 StreamReader 對象和基礎流，並釋聽任何與讀者相關的系統資源。
2	public override int Peek() 返回下一個可用的字符，但不使用它。
3	public override int Read() 從輸入流中讀取下一個字符，並把字符位置往前移一個字符。

下面的實例演示了讀取名爲 Jamaica.txt 的文件。文件以下：

Down the way where the nights are gay
And the sun shines daily on the mountain top
I took a trip on a sailing ship
And when I reached Jamaica
I made a stop

　　編譯和執行上面的程序時，它會顯示文件的內容。

static void Main(string[] args)
        {
            try
            {
                // 建立一個 StreamReader 的實例來讀取文件 
                // using 語句也能關閉 StreamReader
                using (StreamReader sr = new StreamReader("c:/jamaica.txt"))
                {
                    string line;
                   
                    // 從文件讀取並顯示行，直到文件的末尾 
                    while ((line = sr.ReadLine()) != null)
                    {
                        Console.WriteLine(line);
                    }
                }
            }
            catch (Exception e)
            {
                // 向用戶顯示出錯消息
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }

StreamWriter 類（表示編寫器寫入一系列字符）

序號	方法 & 描述
1	public override void Close() 關閉當前的 StreamWriter 對象和基礎流。
2	public override void Flush() 清理當前編寫器的全部緩衝區，使得全部緩衝數據寫入基礎流。
3	public virtual void Write(bool value) 把一個布爾值的文本表示形式寫入到文本字符串或流。（繼承自 TextWriter。）
4	public override void Write( char value ) 把一個字符寫入到流。
5	public virtual void Write( decimal value ) 把一個十進制值的文本表示形式寫入到文本字符串或流。
6	public virtual void Write( double value ) 把一個 8 字節浮點值的文本表示形式寫入到文本字符串或流。
7	public virtual void Write( int value ) 把一個 4 字節有符號整數的文本表示形式寫入到文本字符串或流。
8	public override void Write( string value ) 把一個字符串寫入到流。
9	public virtual void WriteLine() 把行結束符寫入到文本字符串或流。

使用 StreamWriter 類向文件寫入文本數據：

string[] names = new string[] {"Zara Ali", "Nuha Ali"};
            using (StreamWriter sw = new StreamWriter("names.txt"))
            {
                foreach (string s in names)
                {
                    sw.WriteLine(s);

                }
            }

            // 從文件中讀取並顯示每行
            string line = "";
            using (StreamReader sr = new StreamReader("names.txt"))
            {
                while ((line = sr.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }
            Console.ReadKey();

---恢復內容結束---