目錄
?
一、內部類
1. 定義內部類
2. 創建內部類的實例
3. 訪問外部類的私有成員
4. 內部靜態類
5. 使用場景和優點
6. 注意事項
-------------------------------------------
二、代碼塊
1. 控制流語句
1.1. 條件語句
1> if 語句
2> switch 語句
1.2. 循環語句
1> for 循環
2> while 循環
3> do-while 循環
4> foreach 循環
2. 方法定義和調用
3. 定義作用域和變量聲明
4. Lambda表達式和匿名方法（匿名函數）使用代碼塊：
5. 知識小結
-------------------------------------------
講解二：數據類型
一、基本介紹
二、三種變量類型
1. 值類型（Value types）
1.1. 整型
1.2. 浮點型
1.3. 字符型
1.4. 布爾型
?
2. 引用類型（Reference Types）
2.1. 對象（Object）類型
2.2. 動態（Dynamic）類型
2.3. 字符串（String）類型
2.4. 其它
3. 指針類型（Pointer types）
4. 可空類型（Nullable）
4.1. C# 單問號 ? 與 雙問號 ??
4.2. 可空類型（Nullable）
4.3. Null 合并運算符（ ?? ）
4.4. 知識小結
三、類型轉換
1. 隱式類型轉換
實例一
實例二
2. 顯式轉換
實例一
實例二
實例三
實例四
3. 類型轉換方法
實例一
四、類型轉換方法
1. 使用 Convert 類
2. 使用 Parse 方法
3. 使用 TryParse 方法
五、自定義類型轉換
六、總結
-------------------------------------------
講解三：變量
一、基本介紹
二、變量的聲明
三、變量的命名規則
四、變量初始化
五、變量作用域
1. 基本介紹
2. 作用域基本規則
2.1. 局部變量
2.2. 塊級作用域
2.3. 方法參數作用域
2.4. 全局變量
2.5. 靜態變量作用域
2.6. 循環變量作用域
3. 知識小結
六、接受來自用戶的值
七、Lvalues 和 Rvalues
八、變量聲明為常量與只讀字段
-------------------------------------------
講解五：常量
一、基本介紹
二、定義常量
三、常見常量例子
1. 整數常量
2. 浮點常量
3. 字符常量
4. 字符串常量
四、總結
1. 常量與變量的區別
2. 使用場景
3. 注意事項
-------------------------------------------
六、字面量
1. 整數字面量
2. 浮點數字面量
3. 字符字面量
4. 字符串字面量
5. 布爾字面量
5.1. 6. 對象初始化字面量
6. Null 字面量
7. 日期和時間字面量
8. 使用示例
-------------------------------------------
講解七：運算符
一、算術運算符
1. 基本介紹
2. 實例代碼
代碼一
代碼二
運行實例 ?
二、關系運算符
1. 基本介紹
2. 實例代碼
三、邏輯運算符
1. 基本介紹
2. 實例代碼
四、位運算符
1. 基本介紹
2. 實例代碼
五、賦值運算符
1. 基本介紹
2. 實例代碼
六、其他運算符
1. 基本介紹
2. 實例代碼
代碼一
代碼二
七、運算符優先級
算術運算符和賦值運算符的優先級
邏輯運算符的優先級
條件運算符的優先級
-------------------------------------------
講解八：流程控制語句
一、判斷（條件）
1. 判斷語句（條件語句）
2. ? : 運算符
二、循環
1. 循環類型
2. 循環控制語句
3. 無限循環
四、知識小結
?
一、內部類
在C#中，內部類（Inner Class）或嵌套類（Nested Class）指的是定義在另一個類內部的類。這種結構允許你將
相關的功能組織在一起，使得代碼更加模塊化和易于管理。內部類可以訪問外部類的私有成員，這在封裝方面非
常有用。下面是一些關于C#內部類的詳細信息：
1. 定義內部類
內部類可以直接定義在另一個類的內部，如下所示：
public class OuterClass
{private int outerValue = 10;public class InnerClass{public void Display(){Console.WriteLine("Display from InnerClass");// 可以訪問外部類的私有成員Console.WriteLine(new OuterClass().outerValue);}}
}2. 創建內部類的實例
要創建內部類的實例，你需要首先創建一個外部類的實例，然后通過外部類的實例來創建內部類的實例，或者直
接在外部類的方法中創建內部類的實例：
OuterClass.InnerClass innerInstance = new OuterClass.InnerClass();
innerInstance.Display();或者：
OuterClass outerInstance = new OuterClass();
OuterClass.InnerClass innerInstance = outerInstance.GetInnerClass(); // 如果外部類提供了獲取內部類實例的方法3. 訪問外部類的私有成員
內部類可以訪問外部類的私有成員，這是其與外部類緊密耦合的一個特點：
public class OuterClass
{private int privateValue = 100;public void AccessPrivate(){InnerClass inner = new InnerClass();Console.WriteLine(inner.GetPrivateValue()); // 通過內部類訪問外部類的私有成員}public class InnerClass{public int GetPrivateValue(){return new OuterClass().privateValue; // 直接訪問外部類的私有成員}}
}4. 內部靜態類
你也可以將內部類定義為靜態的，這通常用于提供一組靜態方法或屬性，而不依賴于外部類的實例：
public class OuterClass
{public static class StaticInnerClass{public static void StaticMethod(){Console.WriteLine("Static method in StaticInnerClass");}}
}使用靜態內部類時，無需外部類的實例即可訪問其靜態成員：
OuterClass.StaticInnerClass.StaticMethod(); // 直接訪問靜態方法，無需外部類實例。5. 使用場景和優點
- 封裝：內部類可以封裝在外部類中，使得代碼更加組織化和模塊化。
- 訪問控制：內部類可以訪問外部類的私有成員，這在某些設計模式（如工廠模式、單例模式等）中非常有用。
- 組織代碼：將相關的功能組織在同一個類中，使得代碼更加清晰。例如，可以將與特定功能相關的幫助方法放在一個內部類中。
- 減少全局命名空間污染：通過將功能封裝在內部類中，可以減少全局命名空間的污染。
6. 注意事項
- 過度使用內部類可能會導致代碼難以理解，特別是在大型項目中。確保使用它們來組織代碼，而不是僅僅作為一種編程習慣。
在某些情況下，使用靜態類或結構體可能更合適，特別是當你不需要訪問外部類的實例時。
-------------------------------------------
二、代碼塊
在C#中，代碼塊指的是一組語句的集合，它們被一對大括號 {} 包圍。代碼塊在C#中非常重要，它們用于控制
程序的流程，定義作用域，以及組織代碼結構。下面是一些使用代碼塊的常見場景和示例：
1. 控制流語句
1.1. 條件語句
1> if 語句
if (condition)
{// 執行代碼塊
}
else
{// 另一組執行代碼塊
}2> switch 語句
switch (expression)
{case value1:{// 代碼塊break;}case value2:{// 代碼塊break;}default:{// 默認代碼塊break;}
}1.2. 循環語句
1> for 循環
for (int i = 0; i < 10; i++)
{// 循環體
}2> while 循環
while (condition)
{// 循環體
}
3> do-while 循環
do
{// 循環體
} while (condition);4> foreach 循環
foreach (var item in collection)
{// 循環體，遍歷集合中的每個元素
}2. 方法定義和調用
方法定義時使用代碼塊來包含方法體：
void MyMethod()
{// 方法體，包含多條語句的代碼塊
}方法調用時，雖然不直接涉及代碼塊，但方法的執行實際上是在其內部定義的代碼塊中進行的。例如：
MyMethod(); // 調用方法，執行其內部代碼塊中的代碼。3. 定義作用域和變量聲明
在C#中，變量的作用域由其聲明的地方決定。通常，變量在其聲明的大括號內可見和可用：
{ // 開始一個新的作用域或代碼塊int x = 10; // x在這個代碼塊內可見和可用。Console.WriteLine(x); // 輸出 x 的值。
} // x 在這個作用域外不再可見。嘗試訪問 x 會導致編譯錯誤。4. Lambda表達式和匿名方法（匿名函數）使用代碼塊：
雖然Lambda表達式本身不使用大括號包圍的代碼塊，但它們可以包含一個或多個語句：
Action myAction = () =>
{ Console.WriteLine("Hello, World!"); Console.WriteLine("This is a lambda expression.");
};
myAction(); // 調用Lambda表達式，執行其內部代碼塊中的代碼。5. 知識小結
在C#中，代碼塊通過大括號 {} 來定義，它們是控制程序流程、定義變量作用域、組織代碼結構的基本單元。
通過合理地使用代碼塊，可以使程序更加清晰、易于維護和擴展。
-------------------------------------------
講解二：數據類型
一、基本介紹
在C#中，數據類型是基礎且重要的概念，它們決定了變量可以存儲的數據的類型和范圍。
在 C# 中，變量分為以下幾種類型：
- 值類型（Value types）
- 引用類型（Reference types）
- 指針類型（Pointer types）
- 特殊類型（Special Types）-> 可空類型（Nullable）
二、三種變量類型
1. 值類型（Value types）
值類型變量可以直接分配給一個值。它們是從類 System.ValueType 中派生的。
值類型直接包含數據。比如 int、char、float，它們分別存儲數字、字符、浮點數。當您聲明一個 int 類型時，
系統分配內存來存儲值。
值類型直接存儲其數據的值，并且在棧（stack）上分配內存。
下表列出了 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 1028 到 7.9 x 1028) / 100 到 28 | 0.0M |
| double | 64 位雙精度浮點型 | (+/-)5.0 x 10-324 到 (+/-)1.7 x 10308 | 0.0D |
| float | 32 位單精度浮點型 | -3.4 x 1038 到 + 3.4 x 1038 | 0.0F |
| int | 32 位有符號整數類型 | -2,147,483,648 到 2,147,483,647 | 0 |
| long | 64 位有符號整數類型 | -9,223,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) 產生以字節為單位存儲對象或類型的存儲尺寸。
下面舉例獲取任何機器上 int 類型的存儲尺寸：
實例
using System;namespace DataTypeApplication
{class Program{static void Main(string[] args){Console.WriteLine("Size of int: {0}", sizeof(int));Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Size of int: 41.1. 整型
int：32位整數。long：64位整數。short：16位整數。byte：8位無符號整數。uint：32位無符號整數。ulong：64位無符號整數。sbyte：8位有符號整數。ushort：16位無符號整數。
int myInt = 10;
long myLong = 10000000000;
short myShort = 32767;
byte myByte = 255;
uint myUint = 100;
ulong myUlong = 100000000000000;
sbyte mySbyte = -128;
ushort myUshort = 65535;1.2. 浮點型
float：32位浮點數。double：64位浮點數。decimal：128位高精度浮點數，用于金融計算。
float myFloat = 3.14f;
double myDouble = 3.14159265358979;
decimal myDecimal = 123.456789M;1.3. 字符型
char：單個Unicode字符。
char myChar = 'A';1.4. 布爾型
bool：存儲真（true）或假（false）。
bool myBool = true;?
2. 引用類型（Reference Types）
引用類型不包含存儲在變量中的實際數據，但它們包含對變量的引用。
換句話說，它們指的是一個內存位置。使用多個變量時，引用類型可以指向一個內存位置。
如果內存位置的數據是由一個變量改變的，其他變量會自動反映這種值的變化。
內置的 引用類型有：object、dynamic 和 string。
2.1. 對象（Object）類型
對象（Object）類型 是 C# 通用類型系統（Common Type System - CTS）中所有數據類型的終極基類。Object 是 System.Object 類的別名。所以對象（Object）類型可以被分配任何其他類型（值類型、引用類型、
預定義類型或用戶自定義類型）的值。但是，在分配值之前，需要先進行類型轉換。
當一個值類型轉換為對象類型時，則被稱為 裝箱；另一方面，當一個對象類型轉換為值類型時，則被稱為 拆箱。
object obj;
obj = 100; // 這是裝箱2.2. 動態（Dynamic）類型
您可以存儲任何類型的值在動態數據類型變量中。這些變量的類型檢查是在運行時發生的。
聲明動態類型的語法：
dynamic <variable_name> = value;例如：
dynamic d = 20;動態類型與對象類型相似，但是對象類型變量的類型檢查是在編譯時發生的，而動態類型變量的類型檢查是在運
行時發生的。
2.3. 字符串（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>";用戶自定義引用類型有：class、interface 或 delegate。我們將在以后的章節中討論這些類型。
2.4. 其它
- 值類型
- 枚舉
- 引用類型
- 數組
- 非類型
- 注解
3. 指針類型（Pointer types）
指針類型變量存儲另一種類型的內存地址。C# 中的指針與 C 或 C++ 中的指針有相同的功能。
聲明指針類型的語法：
type* identifier;例如：
char* cptr;
int* iptr;我們將在章節"不安全的代碼"中討論指針類型。
4. 可空類型（Nullable）
4.1. C# 單問號 ? 與 雙問號 ??
? 單問號用于對 int、double、bool 等無法直接賦值為 null 的數據類型進行 null 的賦值，意思是這個數據類型
是 Nullable 類型的。
int? i = 3;等同于：
Nullable<int> i = new Nullable<int>(3);int i; //默認值0
int? ii; //默認值null?? 雙問號用于判斷一個變量在為 null 的時候返回一個指定的值。
接下來我們詳細說明。
4.2. 可空類型（Nullable）
C# 提供了一個特殊的數據類型，nullable 類型（可空類型），可空類型可以表示其基礎值類型正常范圍內的值，
再加上一個 null 值。
例如，Nullable< Int32 >，讀作"可空的 Int32"，可以被賦值為 -2,147,483,648 到 2,147,483,647 之間的任意
值，也可以被賦值為 null 值。類似的，Nullable< bool > 變量可以被賦值為 true 或 false 或 null。
在處理數據庫和其他包含可能未賦值的元素的數據類型時，將 null 賦值給數值類型或布爾型的功能特別有用。
例如，數據庫中的布爾型字段可以存儲值 true 或 false，或者，該字段也可以未定義。
聲明一個 nullable 類型（可空類型）的語法如下：
< data_type> ? <variable_name> = null;下面的實例演示了可空數據類型的用法：
using System;
namespace CalculatorApplication
{class NullablesAtShow{static void Main(string[] args){int? num1 = null;int? num2 = 45;double? num3 = new double?();double? num4 = 3.14157;bool? boolval = new bool?();// 顯示值Console.WriteLine("顯示可空類型的值： {0}, {1}, {2}, {3}", num1, num2, num3, num4);Console.WriteLine("一個可空的布爾值： {0}", boolval);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
顯示可空類型的值： , 45, , 3.14157
一個可空的布爾值：4.3. Null 合并運算符（ ?? ）
Null 合并運算符用于定義可空類型和引用類型的默認值。
Null 合并運算符為類型轉換定義了一個預設值，以防可空類型的值為 Null。
Null 合并運算符把操作數類型隱式轉換為另一個可空（或不可空）的值類型的操作數的類型。
如果第一個操作數的值為 null，則運算符返回第二個操作數的值，否則返回第一個操作數的值。
下面的實例演示了這點：
using System;
namespace CalculatorApplication
{class NullablesAtShow{static void Main(string[] args){double? num1 = null;double? num2 = 3.14157;double num3;num3 = num1 ?? 5.34; // num1 如果為空值則返回 5.34Console.WriteLine("num3 的值： {0}", num3);num3 = num2 ?? 5.34;Console.WriteLine("num3 的值： {0}", num3);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
num3 的值： 5.34
num3 的值： 3.141574.4. 知識小結
num3 = num1 ?? 5.34; // num1 如果為空值則返回 5.34
Console.WriteLine("num3 的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);C# 中兩個問號的作用是判斷??左邊的對象是否為 null，如果不為 null 則使用 ?? 左邊的對象，如果為 null 則使
用 ?? 右邊的對象。
比如：
a = b ?? c如果 b 為 null，則 a = c，如果 b 不為 null，則 a = b。
?
?? 可以理解為三元運算符的簡化形式：
num3 = num1 ?? 5.34;
num3 = (num1 == null) ? 5.34 : num1;三、類型轉換
在 C# 中，類型轉換是將一個數據類型的值轉換為另一個數據類型的過程。
C# 中的類型轉換可以分為兩種：隱式類型轉換和顯式類型轉換（也稱為強制類型轉換）。
1. 隱式類型轉換
隱式轉換是不需要編寫代碼來指定的轉換，編譯器會自動進行。
隱式轉換是指將一個較小范圍的數據類型轉換為較大范圍的數據類型時，編譯器會自動完成類型轉換，這些轉換
是 C# 默認的以安全方式進行的轉換, 不會導致數據丟失。
例如，從 int 到 long，從 float 到 double 等。
從小的整數類型轉換為大的整數類型，從派生類轉換為基類。將一個 byte 類型的變量賦值給 int 類型的變量，
編譯器會自動將 byte 類型轉換為 int 類型，不需要顯示轉換。
實例一
byte b = 10;
int i = b; // 隱式轉換，不需要顯式轉換將一個整數賦值給一個長整數，或者將一個浮點數賦值給一個雙精度浮點數，這種轉換不會導致數據丟失：
實例二
int intValue = 42;
long longValue = intValue; // 隱式轉換，從 int 到 long2. 顯式轉換
顯式類型轉換，即強制類型轉換，需要程序員在代碼中明確指定。
顯式轉換是指將一個較大范圍的數據類型轉換為較小范圍的數據類型時，或者將一個對象類型轉換為另一個對象
類型時，需要使用強制類型轉換符號進行顯示轉換，強制轉換會造成數據丟失。
例如，將一個 int 類型的變量賦值給 byte 類型的變量，需要顯示轉換。
實例一
int i = 10;
byte b = (byte)i; // 顯式轉換，需要使用強制類型轉換符號強制轉換為整數類型：
實例二
double doubleValue = 3.14;
int intValue = (int)doubleValue; // 強制從 double 到 int，數據可能損失小數部分強制轉換為浮點數類型：
實例三
int intValue = 42;
float floatValue = (float)intValue; // 強制從 int 到 float，數據可能損失精度強制轉換為字符串類型：
實例四
int intValue = 123;
string stringValue = intValue.ToString(); // 將 int 轉換為字符串下面的實例顯示了一個顯式的類型轉換：
using System;namespace TypeConversionApplication
{class ExplicitConversion{static void Main(string[] args){double d = 5673.74;int i;// 強制轉換 double 為 inti = (int)d;Console.WriteLine(i);Console.ReadKey();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
56733. 類型轉換方法
C# 提供了下列內置的類型轉換方法：
| 序號 | 方法 & 描述 |
| 1 | ToBoolean |
| 2 | ToByte |
| 3 | ToChar |
| 4 | ToDateTime |
| 5 | ToDecimal |
| 6 | ToDouble |
| 7 | ToInt16 |
| 8 | ToInt32 |
| 9 | ToInt64 |
| 10 | ToSbyte |
| 11 | ToSingle |
| 12 | ToString |
| 13 | ToType |
| 14 | ToUInt16 |
| 15 | ToUInt32 |
| 16 | ToUInt64 |
這些方法都定義在 System.Convert 類中，使用時需要包含 System 命名空間。
它們提供了一種安全的方式來執行類型轉換，因為它們可以處理 null值，并且會拋出異常，如果轉換不可能進
行。
例如，使用 Convert.ToInt32 方法將字符串轉換為整數：
string str = "123";
int number = Convert.ToInt32(str); // 轉換成功，number為123如果字符串不是有效的整數表示，Convert.ToInt32 將拋出 FormatException。
下面的實例把不同值的類型轉換為字符串類型：
實例一
using System;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();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
75
53.005
2345.7652
True在進行類型轉換時需要注意以下幾點：
- 隱式轉換只能將較小范圍的數據類型轉換為較大范圍的數據類型，不能將較大范圍的數據類型轉換為較小范圍的數據類型；
- 顯式轉換可能會導致數據丟失或精度降低，需要進行數據類型的兼容性檢查；
- 對于對象類型的轉換，需要進行類型轉換的兼容性檢查和類型轉換的安全性檢查。
四、類型轉換方法
C# 提供了多種類型轉換方法，例如使用 Convert 類、Parse 方法和 TryParse 方法，這些方法可以幫助處理不同
的數據類型之間的轉換。
1. 使用 Convert 類
Convert 類提供了一組靜態方法，可以在各種基本數據類型之間進行轉換。
string str = "123";
int num = Convert.ToInt32(str);2. 使用 Parse 方法
Parse 方法用于將字符串轉換為對應的數值類型，如果轉換失敗會拋出異常。
string str = "123.45";
double d = double.Parse(str);3. 使用 TryParse 方法
TryParse 方法類似于 Parse，但它不會拋出異常，而是返回一個布爾值指示轉換是否成功。
string str = "123.45";
double d;
bool success = double.TryParse(str, out d);if (success) {Console.WriteLine("轉換成功: " + d);
} else {Console.WriteLine("轉換失敗");
}五、自定義類型轉換
C# 還允許你定義自定義類型轉換操作，通過在類型中定義 implicit 或 explicit 關鍵字。
using System;public class Fahrenheit
{public double Degrees { get; set; }public Fahrenheit(double degrees){Degrees = degrees;}// 隱式轉換從Fahrenheit到doublepublic static implicit operator double(Fahrenheit f){return f.Degrees;}// 顯式轉換從double到Fahrenheitpublic static explicit operator Fahrenheit(double d){return new Fahrenheit(d);}
}public class Program
{public static void Main(){Fahrenheit f = new Fahrenheit(98.6);Console.WriteLine("Fahrenheit object: " + f.Degrees + " degrees");double temp = f; // 隱式轉換Console.WriteLine("After implicit conversion to double: " + temp + " degrees");Fahrenheit newF = (Fahrenheit)temp; // 顯式轉換Console.WriteLine("After explicit conversion back to Fahrenheit: " + newF.Degrees + " degrees");}
}以上例子中，我們定義了一個 Fahrenheit 類，并實現了從 Fahrenheit 到 double 的隱式轉換和從 double 到
Fahrenheit 的顯式轉換。
輸出結果將顯示如下：
Fahrenheit object: 98.6 degrees
After implicit conversion to double: 98.6 degrees
After explicit conversion back to Fahrenheit: 98.6 degrees六、總結
在 C# 中，內置的類型轉換方法主要通過以下幾種方式實現：隱式轉換、顯式轉換（強制轉換）、使用 Convert
類的方法、Parse 方法和 TryParse 方法，這些方法廣泛應用于不同數據類型之間的轉換。
以下是 C# 內置類型轉換方法的表格：
| 方法類別 | 方法 | 描述 |
| 隱式轉換 | 自動進行的轉換 | 無需顯式指定，通常用于安全的類型轉換，如從較小類型到較大類型 |
| 顯式轉換（強制轉換） | (type)value | 需要顯式指定，通常用于可能導致數據丟失或轉換失敗的情況 |
| Convert 類方法 | Convert.ToBoolean(value) | 將指定類型轉換為 Boolean |
| ? | Convert.ToByte(value) | 將指定類型轉換為 Byte |
| ? | Convert.ToChar(value) | 將指定類型轉換為 Char |
| ? | Convert.ToDateTime(value) | 將指定類型轉換為 DateTime |
| ? | Convert.ToDecimal(value) | 將指定類型轉換為 Decimal |
| ? | Convert.ToDouble(value) | 將指定類型轉換為 Double |
| ? | Convert.ToInt16(value) | 將指定類型轉換為 Int16（短整型） |
| ? | Convert.ToInt32(value) | 將指定類型轉換為 Int32（整型） |
| ? | Convert.ToInt64(value) | 將指定類型轉換為 Int64（長整型） |
| ? | Convert.ToSByte(value) | 將指定類型轉換為 SByte |
| ? | Convert.ToSingle(value) | 將指定類型轉換為 Single（單精度浮點型） |
| ? | Convert.ToString(value) | 將指定類型轉換為 String |
| ? | Convert.ToUInt16(value) | 將指定類型轉換為 UInt16（無符號短整型） |
| ? | Convert.ToUInt32(value) | 將指定類型轉換為 UInt32（無符號整型） |
| ? | Convert.ToUInt64(value) | 將指定類型轉換為 UInt64（無符號長整型） |
| Parse 方法 | Boolean.Parse(string) | 將字符串解析為 Boolean |
| ? | Byte.Parse(string) | 將字符串解析為 Byte |
| ? | Char.Parse(string) | 將字符串解析為 Char |
| ? | DateTime.Parse(string) | 將字符串解析為 DateTime |
| ? | Decimal.Parse(string) | 將字符串解析為 Decimal |
| ? | Double.Parse(string) | 將字符串解析為 Double |
| ? | Int16.Parse(string) | 將字符串解析為 Int16 |
| ? | Int32.Parse(string) | 將字符串解析為 Int32 |
| ? | Int64.Parse(string) | 將字符串解析為 Int64 |
| ? | SByte.Parse(string) | 將字符串解析為 SByte |
| ? | Single.Parse(string) | 將字符串解析為 Single |
| ? | UInt16.Parse(string) | 將字符串解析為 UInt16 |
| ? | UInt32.Parse(string) | 將字符串解析為 UInt32 |
| ? | UInt64.Parse(string) | 將字符串解析為 UInt64 |
| TryParse 方法 | Boolean.TryParse(string, out bool) | 嘗試將字符串解析為 Boolean，返回布爾值表示是否成功 |
| ? | Byte.TryParse(string, out byte) | 嘗試將字符串解析為 Byte，返回布爾值表示是否成功 |
| ? | Char.TryParse(string, out char) | 嘗試將字符串解析為 Char，返回布爾值表示是否成功 |
| ? | DateTime.TryParse(string, out DateTime) | 嘗試將字符串解析為 DateTime，返回布爾值表示是否成功 |
| ? | Decimal.TryParse(string, out decimal) | 嘗試將字符串解析為 Decimal，返回布爾值表示是否成功 |
| ? | Double.TryParse(string, out double) | 嘗試將字符串解析為 Double，返回布爾值表示是否成功 |
| ? | Int16.TryParse(string, out short) | 嘗試將字符串解析為 Int16，返回布爾值表示是否成功 |
| ? | Int32.TryParse(string, out int) | 嘗試將字符串解析為 Int32，返回布爾值表示是否成功 |
| ? | Int64.TryParse(string, out long) | 嘗試將字符串解析為 Int64，返回布爾值表示是否成功 |
| ? | SByte.TryParse(string, out sbyte) | 嘗試將字符串解析為 SByte，返回布爾值表示是否成功 |
| ? | Single.TryParse(string, out float) | 嘗試將字符串解析為 Single，返回布爾值表示是否成功 |
| ? | UInt16.TryParse(string, out ushort) | 嘗試將字符串解析為 UInt16，返回布爾值表示是否成功 |
| ? | UInt32.TryParse(string, out uint) | 嘗試將字符串解析為 UInt32，返回布爾值表示是否成功 |
| ? | UInt64.TryParse(string, out ulong) | 嘗試將字符串解析為 UInt64，返回布爾值表示是否成功 |
-------------------------------------------
講解三：變量
一、基本介紹
一個變量只不過是一個供程序操作的存儲區的名字。
在 C# 中，變量是用于存儲和表示數據的標識符，即存儲數據的基本單位，它們用于在程序中存儲信息，以便程序
可以在運行時使用這些信息。
在聲明變量時，您需要指定變量的類型，并且可以選擇性地為其分配一個初始值。
這意味著在聲明變量時必須指定它可以存儲的數據類型。
在 C# 中，每個變量都有一個特定的類型，類型決定了變量的內存大小和布局，范圍內的值可以存儲在內存中，可
以對變量進行一系列操作。
我們已經討論了各種數據類型。C# 中提供的基本的值類型大致可以分為以下幾類：
| 類型 | 舉例 |
| 整數類型 | sbyte、byte、short、ushort、int、uint、long、ulong 和 char |
| 浮點型 | float, double |
| 十進制類型 | decimal |
| 布爾類型 | true 或 false 值，指定的值 |
| 空字符串 | string |
| 空類型 | 可為空值的數據類型 |
C# 允許定義其他值類型的變量，比如 enum，也允許定義引用類型變量，比如 class。
這些我們將在以后的章節中進行討論。在本章節中，我們只研究基本變量類型。
C# 4.0引入了動態類型 (dynamic)，它允許在運行時推斷變量的類型。這在一些特殊情況下很有用，但通常最好
使用靜態類型以獲得更好的性能和編譯時類型檢查。
dynamic dynamicVariable = "This can be any type";二、變量的聲明
C# 中變量定義的語法：
<data_type> <variable_list>;在這里，data_type 必須是一個有效的 C# 數據類型，可以是 char、int、float、double 或其他用戶自定義的數
據類型。variable_list 可以由一個或多個用逗號分隔的標識符名稱組成。
一些有效的變量定義如下所示：
int i, j, k;
char c, ch;
float f, salary;
double d;您可以在變量定義時進行初始化：
int i = 100;三、變量的命名規則
在 C# 中，變量的命名需要遵循一些規則：
- 變量名可以包含字母、數字和下劃線。
- 變量名必須以字母或下劃線開頭。
- 變量名區分大小寫。
- 避免使用 C# 的關鍵字作為變量名（如 int, class, if 等）。
- 通常使用駝峰命名法（Camel Case），例如 myVariableName 或 myVariableNameWithNumbers123。
通過以上方式，你可以在C#中有效地使用和理解變量。希望這些信息對你有所幫助！如果有更具體的問題或需要
進一步的解釋，請隨時提問。
int myVariable = 10;
string _userName = "John";四、變量初始化
變量通過在等號后跟一個常量表達式進行初始化（賦值）。初始化的一般形式為：
variable_name = value;變量可以在聲明時被初始化（指定一個初始值）。初始化由一個等號后跟一個常量表達式組成，如下所示：
<data_type> <variable_name> = value;一些實例：
int d = 3, f = 5; /* 初始化 d 和 f. */
byte z = 22; /* 初始化 z. */
double pi = 3.14159; /* 聲明 pi 的近似值 */
char x = 'x'; /* 變量 x 的值為 'x' */正確地初始化變量是一個良好的編程習慣，否則有時程序會產生意想不到的結果。
請看下面的實例，使用了各種類型的變量：
using System;
namespace VariableDefinition
{class Program{static void Main(string[] args){short a;int b ;double c;/* 實際初始化 */a = 10;b = 20;c = a + b;Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
a = 10, b = 20, c = 30五、變量作用域
1. 基本介紹
在 C# 中，變量的作用域定義了變量的可見性和生命周期。
變量的作用域通常由花括號 {} 定義的代碼塊來確定。
以下是關于C#變量作用域的一些基本規則：
2. 作用域基本規則
2.1. 局部變量
在方法、循環、條件語句等代碼塊內聲明的變量是局部變量，它們只在聲明它們的代碼塊中可見。
void MyMethod()
{int localVar = 10; // 局部變量// ...
}
// localVar 在這里不可見2.2. 塊級作用域
在 C# 7及更高版本中，引入了塊級作用域，即使用大括號 {} 創建的任何塊都可以定義變量的作用域。
{int blockVar = 20; // 塊級作用域// ...
}
// blockVar 在這里不可見2.3. 方法參數作用域
方法的參數也有其自己的作用域，它們在整個方法中都是可見的。
void MyMethod(int parameter)
{// parameter 在整個方法中可見// ...
}2.4. 全局變量
在類的成員級別定義的變量是成員變量，它們在整個類中可見，如果在命名空間級別定義，那么它們在整個命名
空間中可見。
class MyClass
{int memberVar = 30; // 成員變量，在整個類中可見
}2.5. 靜態變量作用域
靜態變量是在類級別上聲明的，但它們的作用域也受限于其定義的類。
class MyClass
{static int staticVar = 40; // 靜態變量，在整個類中可見
}2.6. 循環變量作用域
在 for 循環中聲明的循環變量在循環體內可見
for (int i = 0; i < 5; i++)
{// i 在循環體內可見
}
// i 在這里不可見3. 知識小結
總體而言，變量的作用域有助于管理變量的可見性和生命周期，確保變量在其有效范圍內使用，也有助于防止命
名沖突。
C#中的變量可以是局部的或全局的：
- 局部變量：在方法或代碼塊內部聲明的變量，只能在聲明它的方法或代碼塊內部訪問。
- 成員變量（字段）：在類或結構體內部聲明的變量，可以在類的所有方法中訪問。
- 全局變量（靜態成員）：在類或結構體內部使用
static關鍵字聲明的變量，屬于類本身，而不是類的特定實例。
?
六、接受來自用戶的值
System 命名空間中的 Console 類提供了一個函數 ReadLine()，用于接收來自用戶的輸入，并把它存儲到一個
變量中。
例如：
int num;
num = Convert.ToInt32(Console.ReadLine());七、Lvalues 和 Rvalues
C# 中的兩種表達式：
- lvalue：lvalue 表達式可以出現在賦值語句的左邊或右邊。
- rvalue：rvalue 表達式可以出現在賦值語句的右邊，不能出現在賦值語句的左邊。
變量是 lvalue 的，所以可以出現在賦值語句的左邊。
數值是 rvalue 的，因此不能被賦值，不能出現在賦值語句的左邊。
下面是一個有效的語句：
int g = 20;下面是一個無效的語句，會產生編譯時錯誤：
10 = 20;八、變量聲明為常量與只讀字段
- 常量：使用 const 關鍵字聲明，其值在編譯時必須被設定且不可更改。
例如：const int MAX_VALUE = 100;
- 只讀字段：使用 readonly 關鍵字聲明，可以在構造函數中或在聲明時初始化，但不能在對象創建后修
改。例如：readonly int value = 5; 或 public readonly int Value { get; private set; }
（適用于屬性）。
-------------------------------------------
講解五：常量
一、基本介紹
常量（Constants）是一種在編譯時就已經確定其值的變量，即固定值，程序執行期間不會改變。
常量可以是任何基本數據類型，比如整數常量、浮點常量、字符常量或者字符串常量，還有枚舉常量。
常量可以被當作常規的變量，只是它們的值在定義后不能被修改。
常量在聲明時必須初始化，并且在聲明之后不能更改其值。
常量通常用于表示程序中不會改變的值，例如數學常數、配置參數等。
二、定義常量
在C#中，你可以使用 const 關鍵字來定義常量。
const 關鍵字后面必須跟一個類型。常量的命名通常使用大寫字母，以提高可讀性
（盡管這不是強制的，但這是一個良好的編程習慣）。
定義一個常量的語法如下：
const <data_type> <constant_name> = value;下面的代碼演示了如何在程序中定義和使用常量：
using System;public class ConstTest
{class SampleClass{public int x;public int y;public const int c1 = 5;public const int c2 = c1 + 5;public SampleClass(int p1, int p2) {x = p1; y = p2;}}static void Main(){SampleClass mC = new SampleClass(11, 22);Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);Console.WriteLine("c1 = {0}, c2 = {1}", SampleClass.c1, SampleClass.c2);}
}當上面的代碼被編譯和執行時，它會產生下列結果：
x = 11, y = 22
c1 = 5, c2 = 10三、常見常量例子
1. 整數常量
整數常量可以是十進制、八進制或十六進制的常量。前綴指定基數：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 */2. 浮點常量
一個浮點常量是由整數部分、小數點、小數部分和指數部分組成。
您可以使用小數形式或者指數形式來表示浮點常量。
這里有一些浮點常量的實例：
3.14159 /* 合法 */
314159E-5L /* 合法 */
510E /* 非法：不完全指數 */
210f /* 非法：沒有小數或指數 */
.e55 /* 非法：缺少整數或小數 */使用浮點形式表示時，必須包含小數點、指數或同時包含兩者。
使用指數形式表示時，必須包含整數部分、小數部分或同時包含兩者。
有符號的指數是用 e 或 E 表示的。
3. 字符常量
字符常量是括在單引號里，例如，'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 . . . | 一個或多個數字的十六進制數 |
以下是一些轉義序列字符的實例：
namespace EscapeChar
{class Program{static void Main(string[] args){Console.WriteLine("Hello\tWorld\n\n");Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Hello World4. 字符串常量
字符串常量是括在雙引號 "" 里，或者是括在 @"" 里。
字符串常量包含的字符與字符常量相似，可以是：普通字符、轉義序列和通用字符
使用字符串常量時，可以把一個很長的行拆成多個行，可以使用空格分隔各個部分。
這里是一些字符串常量的實例。下面所列的各種形式表示相同的字符串。
string a = "hello, world"; // hello, world
string b = @"hello, world"; // hello, world
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
string i = "one\r\ntwo\r\nthree";
string j = @"one
two
three";四、總結
1. 常量與變量的區別
- 類型：常量必須在聲明時初始化，且其類型必須在編譯時確定。
- 修改：常量在聲明后不能被修改。
- 作用域：常量的作用域可以是局部的或全局的，就像其他變量一樣。
- 性能：由于常量的值在編譯時就已經確定，因此使用常量可以提高程序的性能。
2. 使用場景
- 固定不變的數值：如數學常數、物理常數、配置參數等。
- 提高代碼可讀性：通過使用有意義的名稱代替直接在代碼中硬編碼的值。
- 避免魔法數字：即直接在代碼中出現的數字，通過常量可以使代碼更清晰易懂。
3. 注意事項
- 常量必須是編譯時常量，因此它們的值必須在編譯時已知。這意味著你不能將一個需要通過運行時計算得到的值賦給常量。
- 常量可以是基本數據類型（如int, double, string等）或枚舉類型。
- 常量不能被標記為static或readonly（盡管readonly通常用于字段，但在這里指的是只讀字段的概念，與常量略有不同）。
- 常量不能用作數組大小或作為泛型類型參數。例如，你不能定義
const int arraySize = 5;然后使用int[] myArray = new int[arraySize];，因為arraySize需要在編譯時已知其大小。
通過合理使用常量，可以使你的C#代碼更加清晰、易于維護和調試。
-------------------------------------------
六、字面量
在C#中，字面量（Literal）是一種直接在代碼中表示固定值的表示法。它們可以是數值、布爾值、字符、字符
串、日期等。了解不同類型的字面量對于編寫清晰、易于理解的代碼非常重要。下面是一些C#中常見的字面量類
型及其用法：
1. 整數字面量
整數字面量用于表示整數，可以是十進制、十六進制、八進制或二進制。
- 十進制：例如
123 - 十六進制：以
0x或0X開頭，例如0x1A3 - 八進制：以
0開頭，例如075 - 二進制：以
0b或0B開頭，例如0b1010
2. 浮點數字面量
浮點數字面量用于表示小數或帶指數的數。
- 雙精度浮點數：例如
123.456或1.23e3 - 單精度浮點數：在數字后加
F或f，例如123.456F或1.23e3f
3. 字符字面量
字符字面量用于表示單個字符。
- 單引號：例如
'A'，'1'，'\n'（換行符）
4. 字符串字面量
字符串字面量用于表示文本。
- 雙引號：例如
"Hello, World!" - @ 字符串字面量：用于包含雙引號（"）的字符串，例如
@"He said, \"Hello!\"" - Verbatim 字符串字面量：以
$開頭，例如$"Name: {name}"（C# 6.0及以后版本）
5. 布爾字面量
布爾字面量用于表示真或假。
- true 和 false：例如
true，false
5.1. 6. 對象初始化字面量
對象初始化字面量用于創建和初始化對象。
- 匿名類型：例如
new { Name = "John", Age = 30 } - 集合初始化：例如
new List<int> { 1, 2, 3 }或new[] { 1, 2, 3 }
6. Null 字面量
表示空引用或空值。
- null：例如
string name = null;
7. 日期和時間字面量
用于表示日期和時間。
- DateTime：例如
new DateTime(2023, 1, 1)或DateTime.Now - TimeSpan：例如
new TimeSpan(1, 2, 3)表示1小時2分鐘3秒
8. 使用示例
int integerLiteral = 123; // 整數字面量
double doubleLiteral = 123.456; // 雙精度浮點數字面量
float floatLiteral = 123.456f; // 單精度浮點數字面量
char charLiteral = 'A'; // 字符字面量
string stringLiteral = "Hello, World!"; // 字符串字面量
bool boolLiteral = true; // 布爾字面量
object nullLiteral = null; // Null 字面量
DateTime dateTimeLiteral = new DateTime(2023, 1, 1); // 日期時間字面量掌握這些字面量的使用，可以幫助你更有效地編寫C#代碼。
-------------------------------------------
講解七：運算符
運算符是一種告訴編譯器執行特定的數學或邏輯操作的符號。C# 有豐富的內置運算符，分類如下：
- 算術運算符
- 關系運算符
- 邏輯運算符
- 位運算符
- 賦值運算符
- 其他運算符
本教程將逐一講解算術運算符、關系運算符、邏輯運算符、位運算符、賦值運算符及其他運算符。
一、算術運算符
1. 基本介紹
下表顯示了 C# 支持的所有算術運算符。假設變量 A 的值為 10，變量 B 的值為 20，則：
| 運算符 | 描述 | 實例 |
| + | 把兩個操作數相加 | A + B 將得到 30 |
| - | 從第一個操作數中減去第二個操作數 | A - B 將得到 -10 |
| * | 把兩個操作數相乘 | A * B 將得到 200 |
| / | 分子除以分母 | B / A 將得到 2 |
| % | 取模運算符，整除后的余數 | B % A 將得到 0 |
| ++ | 自增運算符，整數值增加 1 | A++ 將得到 11 |
| -- | 自減運算符，整數值減少 1 | A-- 將得到 9 |
2. 實例代碼
代碼一
請看下面的實例，了解 C# 中所有可用的算術運算符：
using System;namespace OperatorsAppl
{class Program{static void Main(string[] args){int a = 21;int b = 10;int c;c = a + b;Console.WriteLine("Line 1 - c 的值是 {0}", c);c = a - b;Console.WriteLine("Line 2 - c 的值是 {0}", c);c = a * b;Console.WriteLine("Line 3 - c 的值是 {0}", c);c = a / b;Console.WriteLine("Line 4 - c 的值是 {0}", c);c = a % b;Console.WriteLine("Line 5 - c 的值是 {0}", c);// ++a 先進行自增運算再賦值c = ++a;Console.WriteLine("Line 6 - c 的值是 {0}", c);// 此時 a 的值為 22// --a 先進行自減運算再賦值c = --a;Console.WriteLine("Line 7 - c 的值是 {0}", c);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21- c = a++: 先將 a 賦值給 c，再對 a 進行自增運算。
- c = ++a: 先將 a 進行自增運算，再將 a 賦值給 c 。
- c = a--: 先將 a 賦值給 c，再對 a 進行自減運算。
- c = --a: 先將 a 進行自減運算，再將 a 賦值給 c 。
代碼二
using System;namespace OperatorsAppl
{class Program{static void Main(string[] args){int a = 1;int b;// a++ 先賦值再進行自增運算b = a++;Console.WriteLine("a = {0}", a);Console.WriteLine("b = {0}", b);Console.ReadLine();// ++a 先進行自增運算再賦值a = 1; // 重新初始化 ab = ++a;Console.WriteLine("a = {0}", a);Console.WriteLine("b = {0}", b);Console.ReadLine();// a-- 先賦值再進行自減運算a = 1; // 重新初始化 ab= a--;Console.WriteLine("a = {0}", a);Console.WriteLine("b = {0}", b);Console.ReadLine();// --a 先進行自減運算再賦值a = 1; // 重新初始化 ab= --a;Console.WriteLine("a = {0}", a);Console.WriteLine("b = {0}", b);Console.ReadLine();}}
}運行實例 ?
a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0二、關系運算符
1. 基本介紹
下表顯示了 C# 支持的所有關系運算符。假設變量 A 的值為 10，變量 B 的值為 20，則：
| 運算符 | 描述 | 實例 |
| == | 檢查兩個操作數的值是否相等，如果相等則條件為真。 | (A == B) 不為真。 |
| != | 檢查兩個操作數的值是否相等，如果不相等則條件為真。 | (A != B) 為真。 |
| > | 檢查左操作數的值是否大于右操作數的值，如果是則條件為真。 | (A > B) 不為真。 |
| < | 檢查左操作數的值是否小于右操作數的值，如果是則條件為真。 | (A < B) 為真。 |
| >= | 檢查左操作數的值是否大于或等于右操作數的值，如果是則條件為真。 | (A >= B) 不為真。 |
| <= | 檢查左操作數的值是否小于或等于右操作數的值，如果是則條件為真。 | (A <= B) 為真。 |
2. 實例代碼
請看下面的實例，了解 C# 中所有可用的關系運算符：
using System;class Program
{static void Main(string[] args){int a = 21;int b = 10;if (a == b){Console.WriteLine("Line 1 - a 等于 b");}else{Console.WriteLine("Line 1 - a 不等于 b");}if (a < b){Console.WriteLine("Line 2 - a 小于 b");}else{Console.WriteLine("Line 2 - a 不小于 b");}if (a > b){Console.WriteLine("Line 3 - a 大于 b");}else{Console.WriteLine("Line 3 - a 不大于 b");}/* 改變 a 和 b 的值 */a = 5;b = 20;if (a <= b){Console.WriteLine("Line 4 - a 小于或等于 b");}if (b >= a){Console.WriteLine("Line 5 - b 大于或等于 a");}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a三、邏輯運算符
1. 基本介紹
下表顯示了 C# 支持的所有邏輯運算符。假設變量 A 為布爾值 true，變量 B 為布爾值 false，則：
| 運算符 | 描述 | 實例 |
| && | 稱為邏輯與運算符。如果兩個操作數都非零，則條件為真。 | (A && B) 為假。 |
| || | 稱為邏輯或運算符。如果兩個操作數中有任意一個非零，則條件為真。 | (A || B) 為真。 |
| ! | 稱為邏輯非運算符。用來逆轉操作數的邏輯狀態。如果條件為真則邏輯非運算符將使其為假。 | !(A && B) 為真。 |
2. 實例代碼
請看下面的實例，了解 C# 中所有可用的邏輯運算符：
using System;namespace OperatorsAppl
{class Program{static void Main(string[] args){bool a = true;bool b = true;if (a && b){Console.WriteLine("Line 1 - 條件為真");}if (a || b){Console.WriteLine("Line 2 - 條件為真");}/* 改變 a 和 b 的值 */a = false;b = true;if (a && b){Console.WriteLine("Line 3 - 條件為真");}else{Console.WriteLine("Line 3 - 條件不為真");}if (!(a && b)){Console.WriteLine("Line 4 - 條件為真");}Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Line 1 - 條件為真
Line 2 - 條件為真
Line 3 - 條件不為真
Line 4 - 條件為真四、位運算符
1. 基本介紹
位運算符作用于位，并逐位執行操作。&、 | 和 ^ 的真值表如下所示：
| p | q | p & q | p | q | p ^ q |
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
假設如果 A = 60，且 B = 13，現在以二進制格式表示，它們如下所示：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表列出了 C# 支持的位運算符。假設變量 A 的值為 60，變量 B 的值為 13，則：
| 運算符 | 描述 | 實例 |
| & | 如果同時存在于兩個操作數中，二進制 AND 運算符復制一位到結果中。 | (A & B) 將得到 12，即為 0000 1100 |
| | | 如果存在于任一操作數中，二進制 OR 運算符復制一位到結果中。 | (A | B) 將得到 61，即為 0011 1101 |
| ^ | 如果存在于其中一個操作數中但不同時存在于兩個操作數中，二進制異或運算符復制一位到結果中。 | (A ^ B) 將得到 49，即為 0011 0001 |
| ~ | 按位取反運算符是一元運算符，具有"翻轉"位效果，即0變成1，1變成0，包括符號位。 | (~A ) 將得到 -61，即為 1100 0011，一個有符號二進制數的補碼形式。 |
| << | 二進制左移運算符。左操作數的值向左移動右操作數指定的位數。 | A << 2 將得到 240，即為 1111 0000 |
| >> | 二進制右移運算符。左操作數的值向右移動右操作數指定的位數。 | A >> 2 將得到 15，即為 0000 1111 |
2. 實例代碼
請看下面的實例，了解 C# 中所有可用的位運算符：
using System;
namespace OperatorsAppl
{class Program{static void Main(string[] args){int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */int c = 0; c = a & b; /* 12 = 0000 1100 */ Console.WriteLine("Line 1 - c 的值是 {0}", c );c = a | b; /* 61 = 0011 1101 */Console.WriteLine("Line 2 - c 的值是 {0}", c);c = a ^ b; /* 49 = 0011 0001 */Console.WriteLine("Line 3 - c 的值是 {0}", c);c = ~a; /*-61 = 1100 0011 */Console.WriteLine("Line 4 - c 的值是 {0}", c);c = a << 2; /* 240 = 1111 0000 */Console.WriteLine("Line 5 - c 的值是 {0}", c);c = a >> 2; /* 15 = 0000 1111 */Console.WriteLine("Line 6 - c 的值是 {0}", c);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15五、賦值運算符
1. 基本介紹
下表列出了 C# 支持的賦值運算符：
| 運算符 | 描述 | 實例 |
| = | 簡單的賦值運算符，把右邊操作數的值賦給左邊操作數 | C = A + B 將把 A + B 的值賦給 C |
| += | 加且賦值運算符，把右邊操作數加上左邊操作數的結果賦值給左邊操作數 | C += A 相當于 C = C + A |
| -= | 減且賦值運算符，把左邊操作數減去右邊操作數的結果賦值給左邊操作數 | C -= A 相當于 C = C - A |
| *= | 乘且賦值運算符，把右邊操作數乘以左邊操作數的結果賦值給左邊操作數 | C *= A 相當于 C = C * A |
| /= | 除且賦值運算符，把左邊操作數除以右邊操作數的結果賦值給左邊操作數 | C /= A 相當于 C = C / A |
| %= | 求模且賦值運算符，求兩個操作數的模賦值給左邊操作數 | C %= A 相當于 C = C % A |
| <<= | 左移且賦值運算符 | C <<= 2 等同于 C = C << 2 |
| >>= | 右移且賦值運算符 | C >>= 2 等同于 C = C >> 2 |
| &= | 按位與且賦值運算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位異或且賦值運算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且賦值運算符 | C |= 2 等同于 C = C | 2 |
2. 實例代碼
請看下面的實例，了解 C# 中所有可用的賦值運算符：
using System;namespace OperatorsAppl
{class Program{static void Main(string[] args){int a = 21;int c;c = a;Console.WriteLine("Line 1 - = c 的值 = {0}", c);c += a;Console.WriteLine("Line 2 - += c 的值 = {0}", c);c -= a;Console.WriteLine("Line 3 - -= c 的值 = {0}", c);c *= a;Console.WriteLine("Line 4 - *= c 的值 = {0}", c);c /= a;Console.WriteLine("Line 5 - /= c 的值 = {0}", c);c = 200;c %= a;Console.WriteLine("Line 6 - %= c 的值 = {0}", c);c <<= 2;Console.WriteLine("Line 7 - <<= c 的值 = {0}", c);c >>= 2;Console.WriteLine("Line 8 - >>= c 的值 = {0}", c);c &= 2;Console.WriteLine("Line 9 - &= c 的值 = {0}", c);c ^= 2;Console.WriteLine("Line 10 - ^= c 的值 = {0}", c);c |= 2;Console.WriteLine("Line 11 - |= c 的值 = {0}", c);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
Line 1 - = c 的值 = 21
Line 2 - += c 的值 = 42
Line 3 - -= c 的值 = 21
Line 4 - *= c 的值 = 441
Line 5 - /= c 的值 = 21
Line 6 - %= c 的值 = 11
Line 7 - <<= c 的值 = 44
Line 8 - >>= c 的值 = 11
Line 9 - &= c 的值 = 2
Line 10 - ^= c 的值 = 0
Line 11 - |= c 的值 = 2六、其他運算符
1. 基本介紹
下表列出了 C# 支持的其他一些重要的運算符，包括 sizeof、typeof 和 ? :。
| 運算符 | 描述 | 實例 |
| sizeof() | 返回數據類型的大小。 | sizeof(int)，將返回 4. |
| typeof() | 返回 class 的類型。 | typeof(StreamReader); |
| & | 返回變量的地址。 | &a; 將得到變量的實際地址。 |
| * | 變量的指針。 | *a; 將指向一個變量。 |
| ? : | 條件表達式 | 如果條件為真 ? 則為 X : 否則為 Y |
| is | 判斷對象是否為某一類型。 | If( Ford is Car) // 檢查 Ford 是否是 Car 類的一個對象。 |
| as | 強制轉換，即使轉換失敗也不會拋出異常。 | Object obj = new StringReader("Hello"); |
2. 實例代碼
代碼一
using System;namespace OperatorsAppl
{class Program{static void Main(string[] args){/* sizeof 運算符的實例 */Console.WriteLine("int 的大小是 {0}", sizeof(int));Console.WriteLine("short 的大小是 {0}", sizeof(short));Console.WriteLine("double 的大小是 {0}", sizeof(double));/* 三元運算符的實例 */int a, b;a = 10;b = (a == 1) ? 20 : 30;Console.WriteLine("b 的值是 {0}", b);b = (a == 10) ? 20 : 30;Console.WriteLine("b 的值是 {0}", b);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20typeof 關鍵字用于獲取一個類型的類型對象，它通常用于反射和動態創建類型實例。
下面是一個使用 typeof 的簡單示例：
代碼二
using System;class Program
{static void Main(string[] args){Type type = typeof(string);Console.WriteLine(type.FullName);Console.ReadKey();}
}在上面的代碼中，我們使用 typeof 關鍵字來獲取 string 類型的類型對象，并將其存儲在 Type 類型的變量 type
中，然后，我們使用 FullName 屬性打印該類型的完全限定名。
當上面的代碼被編譯和執行時，它會產生下列結果：
System.String七、運算符優先級
運算符的優先級確定表達式中項的組合。這會影響到一個表達式如何計算。某些運算符比其他運算符有更高的優
先級，例如，乘除運算符具有比加減運算符更高的優先級。
例如 x = 7 + 3 * 2，在這里，x 被賦值為 13，而不是 20，因為運算符 * 具有比 + 更高的優先級，所以首先計算
乘法 3*2，然后再加上 7。
下表將按運算符優先級從高到低列出各個運算符，具有較高優先級的運算符出現在表格的上面，具有較低優先級
的運算符出現在表格的下面。在表達式中，較高優先級的運算符會優先被計算。
優先級簡易概括：有括號先括號，后乘除在加減，然后位移再關系，邏輯完后條件，最后一個逗號 , 。
| 類別 | 運算符 | 結合性 |
| 后綴 | () [] -> . ++ - - | 從左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 從右到左 |
| 乘除 | * / % | 從左到右 |
| 加減 | + - | 從左到右 |
| 移位 | << >> | 從左到右 |
| 關系 | < <= > >= | 從左到右 |
| 相等 | == != | 從左到右 |
| 位與 AND | & | 從左到右 |
| 位異或 XOR | ^ | 從左到右 |
| 位或 OR | | | 從左到右 |
| 邏輯與 AND | && | 從左到右 |
| 邏輯或 OR | || | 從左到右 |
| 條件 | ?: | 從右到左 |
| 賦值 | = += -= *= /= %=>>= <<= &= ^= |= | 從右到左 |
| 逗號 | , | 從左到右 |
實例
using System;namespace OperatorsAppl
{class Program{static void Main(string[] args){int a = 20;int b = 10;int c = 15;int d = 5;int e;e = (a + b) * c / d; // ( 30 * 15 ) / 5Console.WriteLine("(a + b) * c / d 的值是 {0}", e);e = ((a + b) * c) / d; // (30 * 15 ) / 5Console.WriteLine("((a + b) * c) / d 的值是 {0}", e);e = (a + b) * (c / d); // (30) * (15/5)Console.WriteLine("(a + b) * (c / d) 的值是 {0}", e);e = a + (b * c) / d; // 20 + (150/5)Console.WriteLine("a + (b * c) / d 的值是 {0}", e);Console.ReadLine();}}
}當上面的代碼被編譯和執行時，它會產生下列結果：
(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50算術運算符和賦值運算符的優先級
int a = 10, b = 5, c = 2;
int result = a + b * c; // 先計算乘法，再計算加法
Console.WriteLine(result); // 輸出20result = (a + b) * c; // 先計算加法，再計算乘法
Console.WriteLine(result); // 輸出30a += b * c; // 先計算乘法，再執行加法賦值
Console.WriteLine(a); // 輸出20邏輯運算符的優先級
bool a = true, b = false, c = true;
bool result = a || b && c; // 先計算與運算，再計算或運算
Console.WriteLine(result); // 輸出trueresult = (a || b) && c; // 先計算或運算，再計算與運算
Console.WriteLine(result); // 輸出trueresult = a || (b && c); // 先計算與運算，再計算或運算
Console.WriteLine(result); // 輸出true條件運算符的優先級
int a = 10, b = 5;
string result = a > b ? "a大于b" : "a不大于b"; // 先判斷大小關系，再執行條件語句
Console.WriteLine(result); // 輸出"a大于b"注意：由于括號可以改變運算符優先級，所以在實際應用中建議盡可能使用括號來明確運算順序，提高代碼的可
讀性和準確性。
-------------------------------------------
講解八：流程控制語句
在C#中，流程控制語句用于控制程序中代碼的執行順序。
這些語句允許開發者根據條件執行代碼塊，循環執行代碼塊，或者跳過某些代碼塊。
以下是C#中主要的流程控制語句的詳細解釋：
一、判斷（條件）
判斷結構要求程序員指定一個或多個要評估或測試的條件，以及條件為真時要執行的語句（必需的）和條件為假
時要執行的語句（可選的）。
下面是大多數編程語言中典型的判斷結構的一般形式：
?
1. 判斷語句（條件語句）
C# 提供了以下類型的判斷語句。點擊鏈接查看每個語句的細節。
| 語句 | 描述 |
| if 語句 | 一個 if 語句 由一個布爾表達式后跟一個或多個語句組成。 |
| if...else 語句 | 一個 if 語句 后可跟一個可選的 else 語句，else 語句在布爾表達式為假時執行。 |
| 嵌套 if 語句 | 您可以在一個 if 或 else if 語句內使用另一個 if 或 else if 語句。 |
| switch 語句 | 一個 switch 語句允許測試一個變量等于多個值時的情況。 |
| 嵌套 switch 語句 | 您可以在一個 switch 語句內使用另一個 switch 語句。 |
2. ? : 運算符
我們已經在前面的章節中講解了 條件運算符 ? :，可以用來替代 if...else 語句。它的一般形式如下：
Exp1 ? Exp2 : Exp3;其中，Exp1、Exp2 和 Exp3 是表達式。請注意，冒號的使用和位置。
? 表達式的值是由 Exp1 決定的。如果 Exp1 為真，則計算 Exp2 的值，結果即為整個 ? 表達式的值。
如果 Exp1 為假，則計算 Exp3 的值，結果即為整個 ? 表達式的值。
二、循環
有的時候，可能需要多次執行同一塊代碼。
一般情況下，語句是順序執行的：函數中的第一個語句先執行，接著是第二個語句，依此類推。
編程語言提供了允許更為復雜的執行路徑的多種控制結構。
循環語句允許我們多次執行一個語句或語句組，下面是大多數編程語言中循環語句的一般形式：
?
1. 循環類型
C# 提供了以下幾種循環類型。點擊鏈接查看每個類型的細節。
| 循環類型 | 描述 |
| while 循環 | 當給定條件為真時，重復語句或語句組。它會在執行循環主體之前測試條件。 |
| for/foreach 循環 | 多次執行一個語句序列，簡化管理循環變量的代碼。 |
| do...while 循環 | 除了它是在循環主體結尾測試條件外，其他與 while 語句類似。 |
| 嵌套循環 | 您可以在 while、for 或 do..while 循環內使用一個或多個循環。 |
2. 循環控制語句
循環控制語句更改執行的正常序列。當執行離開一個范圍時，所有在該范圍中創建的自動對象都會被銷毀。
C# 提供了下列的控制語句。點擊鏈接查看每個語句的細節。
| 控制語句 | 描述 |
| break 語句 | 終止 loop 或 switch 語句，程序流將繼續執行緊接著 loop 或 switch 的下一條語句。 |
| continue 語句 | 跳過本輪循環，開始下一輪循環。 |
| goto 語句（不推薦使用） |
|
3. 無限循環
如果條件永遠不為假，則循環將變成無限循環。
for 循環在傳統意義上可用于實現無限循環。
由于構成循環的三個表達式中任何一個都不是必需的，您可以將某些條件表達式留空來構成一個無限循環。
using System;namespace Loops
{class Program{static void Main(string[] args){for (; ; ){Console.WriteLine("Hey! I am Trapped");}}}
}當條件表達式不存在時，它被假設為真。您也可以設置一個初始值和增量表達式，但是一般情況下，程序員偏向
于使用 for(;;) 結構來表示一個無限循環。
四、知識小結
通過使用這些流程控制語句，你可以精確地控制C#程序中代碼的執行流程，從而實現復雜的邏輯和算法。
每種語句都有其特定的用途和場景，合理使用這些語句可以使你的程序更加高效和易于管理。
?
