一、程序結(jié)構(gòu)

1、基本語法

using System; // C#程序第一條語句都是 using System; 
// using 關(guān)鍵字（可多個）：在程序中包含命名空間

namespace RectangleApplication // namespace 聲明（可多個）：包含一系列的類
{
    class Rectangle // class 聲明（可多個）：包含程序數(shù)據(jù)和方法聲明
    {
        double width; // 變量聲明：類的屬性或數(shù)據(jù)成員，用于存儲數(shù)據(jù)
        double length;

        public void Acceptdetails() // 函數(shù)聲明：一系列執(zhí)行指定任務(wù)的語句
        {
            width = 3.5;
            length = 4.5;
        }
        public double GetArea()
        {
            return width * length;
        }
        public void Display()
        {
            Console.WriteLine("Length:{0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
    class ExecuteRectangle // 實例化 Rectangle 的類
    {
        static void Main(string[] args) // Main 方法：定義類的動作（所有 C# 程序的入口點，程序執(zhí)行從此開始）
        {
            Rectangle r = new Rectangle(); // 實例化 Rectangle
            r.Acceptdetails();
            r.Display();
            Console.ReadLine(); // 輸出內(nèi)容
        }
    }
}

2、類的命名

1. 必須以 A-Z / _ / @ 開頭，不能是數(shù)字，之后可以跟 A-Z、0-9、_、@
2. 不能包含任何空格或特殊符號，比如 ?-+!#%^&*()[]{}.;:"'/\
3. 不能與關(guān)鍵字同名（除非添加 @ 前綴，@不作為標(biāo)識符本身的一部分），不能與類庫同名
4. 必須區(qū)分大小寫（PascalCase命名法）

3、關(guān)鍵字

• 保留關(guān)鍵字
  abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in in(generic modifier) int interface internal is lock long namespace new null object operator out out(generic modifier) override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while

• 上下文關(guān)鍵字
  add alias ascending descending dynamic from get global group into join let orderby partial(type) partial(method) remove select set

二、數(shù)據(jù)類型

1、值（Value）類型

直接包含數(shù)據(jù)，當(dāng)聲明一個值類型時，系統(tǒng)分配內(nèi)存來存儲值

int i = 75;
float f = 53.005f;
double d = 2345.7652;
bool b = true;

Console.WriteLine("Size of int: {0}", sizeof(int)); // 獲取任何機器上 int 類型的存儲尺寸

2、引用（Reference）類型

不包含實際數(shù)據(jù)，僅包含對變量的引用（指向一個內(nèi)存位置）

• 對象類型object：通用類型系統(tǒng)中所有數(shù)據(jù)類型的終極基類，可以被分配任何其他數(shù)據(jù)類型的值（分配值之前需先進行類型轉(zhuǎn)換）

int i = 10;
object obj = i; // 裝箱：將一個值類型轉(zhuǎn)換為對象類型
int j = (int)obj; // 拆箱：將一個對象類型轉(zhuǎn)換為值類型

// 拆箱時強轉(zhuǎn)的值類型，應(yīng)與裝箱時的值類型一致

裝箱：在堆中自動創(chuàng)建一個對象實例，然后將該值復(fù)制到新對象內(nèi)

拆箱：檢查是否是給定值類型的一個裝箱值，然后將該值從實例復(fù)制到值類型變量中

• 動態(tài)類型dynamic：存儲任何類型的值，動態(tài)類型變量的類型檢查是在運行時發(fā)生的

/* 聲明動態(tài)類型的語法 */
dynamic <variable_name> = value;

dynamic d = 20;

• 字符串類型string：允許給變量分配任何字符串值（兩種分配形式：引號和 @引號）

/* 聲明字符串類型的語法 */
string <variable_name> = value;

String str = "runoob.com";
string str = @"C:\Windows"; // 字符串前加 @ 可取消字符串中\(zhòng)的轉(zhuǎn)義，將內(nèi)容原樣輸出
string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>"; // @字符串內(nèi)容可換行書寫，換行符及縮進空格都計算在字符串長度之內(nèi)

3、指針（Pointer）類型

存儲另一種類型的內(nèi)存地址

/* 聲明指針類型的語法 */
type* identifier;

char* cptr;

4、無（Void）類型

對定義函數(shù)的參數(shù)類型、返回值、函數(shù)中指針類型進行聲明

public class Void Test{} // 無返回值
void* identifier; // 無類型指針：可以指向任何類型的數(shù)據(jù)

// void幾乎只有“注釋”和限制程序的作用，定義一個void變量沒有意義

使用說明：

1. 如果函數(shù)沒有返回值，那么應(yīng)聲明為void類型
2. 如果函數(shù)無參數(shù)，那么應(yīng)聲明其參數(shù)為void
3. 小心使用void指針類型
4. 如果函數(shù)的參數(shù)可以是任意類型指針，那么應(yīng)聲明其參數(shù)為void *
5. void不能代表一個真實的變量

三、類型轉(zhuǎn)換

• 隱式類型轉(zhuǎn)換：以安全方式進行轉(zhuǎn)換，不會導(dǎo)致數(shù)據(jù)丟失
• 顯式類型轉(zhuǎn)換：強制類型轉(zhuǎn)換，需要強制轉(zhuǎn)換運算符，并且會造成數(shù)據(jù)丟失

double d = 5673.74;
int i;
i = (int)d; // 強制轉(zhuǎn)換 double 為 int，輸出 5673

int i = 75;
float f = 53.005f;
double d = 2345.7652;
bool b = true;

Console.WriteLine(i.ToString()); // 輸出 "75"
Console.WriteLine(f.ToString()); // 輸出 "53.005"
Console.WriteLine(d.ToString()); // 輸出 "2345.7652"
Console.WriteLine(b.ToString()); // 輸出 "True"

四、變量

變量只是一個供程序操作的存儲區(qū)的名字；每個變量都有一個特定的類型，類型決定了變量的內(nèi)存大小和布局；范圍內(nèi)的值可以存儲在內(nèi)存中，可以對變量進行一系列操作

1、變量定義

/* 變量定義的語法 */
<data_type> <variable_list>;

// data_type：一個有效的數(shù)據(jù)類型
// variable_list：由一個或多個用逗號分隔的標(biāo)識符名稱組成

int i, j, k;
char c, ch;
float f, salary;
double d;

2、變量初始化

/* 變量初始化的語法 */
variable_name = value;
<data_type> <variable_name> = value;

byte d = 3, f = 5;
double pi = 3.14159;
char x = 'x';

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

// ReadLine()：接收來自用戶的輸入，并把它存儲到一個變量中
// Convert.ToInt32()：把用戶輸入的數(shù)據(jù)轉(zhuǎn)換為 int 數(shù)據(jù)類型

3、兩種表達式

• lvalue 表達式：可以出現(xiàn)在賦值語句的左邊或右邊
• rvalue 表達式：可以出現(xiàn)在賦值語句的右邊，不能出現(xiàn)在賦值語句的左邊

五、常量

常量是固定值，程序執(zhí)行期間不會改變；常量可以是任何基本數(shù)據(jù)類型，可以被當(dāng)作常規(guī)的變量，只是它們的值在定義后不能被修改

/* 定義常量的語法 */
const <data_type> <constant_name> = value;

const int c1 = 5;

1、整數(shù)常量

85 // 十進制
0213 // 八進制
0x4b // 十六進制
30 // 整型
30u // 無符號整型
30l // 長整型
30ul // 無符號長整型

2、浮點常量

3.14159 // 小數(shù)形式：必須包含小數(shù)點或指數(shù)，或同時包含兩者
314159E-5L // 指數(shù)形式：必須包含整數(shù)或小數(shù)，或同時包含兩者，有符號的指數(shù)用e或E表示

3、字符常量

'x' // 普通字符
'\t' // 轉(zhuǎn)義序列
'\u02C0' // 通用字符

4、字符串常量

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、算術(shù)運算符

int a = 1;
int b;

b = a++; // 先將a賦值給b，再對a進行自增運算：a → 2, b → 1
b = ++a; // 先將a進行自增運算，再將a賦值給b：a → 2, b → 2
b = a--; // 先將a賦值給b，再對a進行自減運算：a → 0, b → 1
b = --a; // 先將a進行自減運算，再將a賦值給b：a → 0, b → 0

2、關(guān)系運算符

3、邏輯運算符

4、位運算符

將條件值換算為二進制數(shù)后進行位運算，再將結(jié)果換算回去得出最終結(jié)果

5、賦值運算符

6、其他運算符

運算符優(yōu)先級：
() [] -> . ++ - -
+ - ! ~ ++ - - (type)* & sizeof()
* / %
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
||
?:
= += -= *= /= %=>>= <<= &= ^= |=
,

七、判斷

• if 語句

if (boolean_expression)
{
   /* 如果布爾表達式為真將執(zhí)行的語句 */
}

• if…else 語句

if (boolean_expression)
{
   /* 如果布爾表達式為真將執(zhí)行的語句 */
}
else
{
  /* 如果布爾表達式為假將執(zhí)行的語句 */
}

// 條件運算符可替代 if...else 語句：
Exp1 ? Exp2 : Exp3;

// if...else if...else 語句：
if (boolean_expression 1)
{
   /* 當(dāng)布爾表達式 1 為真時執(zhí)行 */
}
else if (boolean_expression 2)
{
   /* 當(dāng)布爾表達式 2 為真時執(zhí)行 */
}
else if (boolean_expression 3)
{
   /* 當(dāng)布爾表達式 3 為真時執(zhí)行 */
}
else 
{
   /* 當(dāng)上面條件都不為真時執(zhí)行 */
}

// 另一種寫法：
if (a == true)
    x = 1; // 若不書寫花括號{}，則默認只第一條語句由if執(zhí)行
    y = 2; // 之后的語句則在if語句之后執(zhí)行
    z = 3;

• 嵌套 if 語句

if (boolean_expression 1)
{
   /* 當(dāng)布爾表達式 1 為真時執(zhí)行 */
   if (boolean_expression 2)
   {
      /* 當(dāng)布爾表達式 2 為真時執(zhí)行 */
   }
}

• switch 語句

switch (expression){
    case constant-expression  :
       statement(s);
       break; 
    case constant-expression  :
       statement(s);
       break; 
  
    /* 您可以有任意數(shù)量的 case 語句 */
    default : /* 可選的 */
       statement(s);
       break; 
}

switch語句規(guī)則：

1. expression 必須是一個整型或枚舉類型，或者是一個 class 類型，其中 class 有一個單一的轉(zhuǎn)換函數(shù)將其轉(zhuǎn)換為整型或枚舉類型。
2. 在一個 switch 中可以有任意數(shù)量的 case 語句，每個 case 后跟一個要比較的值和一個冒號。
3. case 的 constant-expression 必須與 switch 中的變量具有相同的數(shù)據(jù)類型，且必須是一個常量。
4. 當(dāng)被測試的變量等于 case 中的常量時，case 后跟的語句將被執(zhí)行，直到遇到 break 語句時switch 終止，控制流將跳轉(zhuǎn)到 switch 語句后的下一行。
5. 如果 case 語句中有處理語句，則必須包含 break 或其他跳轉(zhuǎn)語句；如果 case 語句為空，則可以不包含 break，控制流將會繼續(xù)后續(xù)的 case，直到遇到 break 為止。
6. 一個 switch 語句結(jié)尾可以有一個可選的 default case，用于在上面所有 case 都不為真時執(zhí)行一個任務(wù)，default case 中的 break 語句不是必需的。
7. C# 不支持從一個 case 標(biāo)簽顯式貫穿到另一個 case 標(biāo)簽，如需要，可以使用 goto 一個 switch-case 或 goto default。

• 嵌套 switch 語句

switch (ch1)
{
   case 'A':
      printf("這個 A 是外部 switch 的一部分" );
      switch (ch2)
      {
         case 'A':
            printf("這個 A 是內(nèi)部 switch 的一部分" );
            break;
         case 'B': /* 內(nèi)部 B case 代碼 */
      }
      break;
   case 'B': /* 外部 B case 代碼 */
}

八、循環(huán)

1、循環(huán)類型

• while 循環(huán)

while (condition) // condition 可以是任意的表達式，當(dāng)為任意非零值時都為真
{
   statement(s); // 可以是一個單獨的語句，也可以是幾個語句組成的代碼塊
}

• for/foreach 循環(huán)

/* for 循環(huán)語法 */
for (init; condition; increment)
{
   statement(s);
}

/* foreach 循環(huán)語法 */
foreach (type objName in collection/Array)
{
   statement(s);
}

int[] fibarray = new int[] {0, 1, 1, 2, 3, 5, 8, 13};
foreach (int element in fibarray)
{
    System.Console.WriteLine(element);
}

for循環(huán)控制流：

1. init 會首先被執(zhí)行，且只會執(zhí)行一次；允許聲明并初始化任何循環(huán)控制變量，也可以只寫一個分號。
2. 判斷 condition，如果為真則執(zhí)行循環(huán)主體，如果為假則直接跳到緊接著 for 循環(huán)的下一條語句。
3. 執(zhí)行完 for 循環(huán)主體后，控制流會跳回 increment 語句，允許更新循環(huán)控制變量，也可以留空。
4. 重復(fù)判斷 condition，直到條件變?yōu)榧贂r，循環(huán)終止。

• do…while 循環(huán)

do
{
   statement(s);
} while (condition);

do…while循環(huán)控制流：

1. 條件表達式出現(xiàn)在循環(huán)的尾部，所以循環(huán)中的 statement(s) 會在條件被測試之前至少執(zhí)行一次。
2. 如果 condition 為真，控制流會跳轉(zhuǎn)回上面的 do，重新執(zhí)行循環(huán)中的 statement(s)。
3. 重復(fù)判斷 condition，直到條件變?yōu)榧贂r，循環(huán)終止。

• 嵌套循環(huán)

/* 嵌套 for 循環(huán)語法 */
for (init; condition; increment)
{
   for (init; condition; increment)
   {
      statement(s);
   }
   statement(s);
}

/* 嵌套 while 循環(huán)語法 */
while (condition)
{
   while (condition)
   {
      statement(s);
   }
   statement(s);
}

/* 嵌套 do...while 循環(huán)語法 */
do
{
   statement(s);
   do
   {
      statement(s);
   } while (condition);

} while (condition);

2、循環(huán)控制語句

用于更改執(zhí)行的正常序列，當(dāng)執(zhí)行離開一個范圍時，所有在該范圍中創(chuàng)建的自動對象都會被銷毀

• break 語句

int a = 10;
while (a < 20)
{
    a++;
    if (a > 15)
    {
        break; // a>15時終止while循環(huán)
    }
}

• continue 語句

int a = 10;
do
{
    if (a == 15)
    {
        a = a + 1;
        continue; // a==15時跳過這次迭代，繼續(xù)循環(huán)
    }
    a++;
} while (a < 20);

3、無限循環(huán)

如果條件永遠不為假，則循環(huán)將變成無限循環(huán)

for (; ; ) // 當(dāng)條件表達式不存在時，它被假設(shè)為真
{
    Console.WriteLine("陷入死循環(huán)啦！");
}

九、封裝

把一個或多個項目封閉在一個物理的或者邏輯的包中，通過訪問修飾符設(shè)置使用者的訪問權(quán)限，防止對實現(xiàn)細節(jié)的訪問

1、Public 訪問修飾符

允許一個類將其成員變量和成員函數(shù)暴露給所有函數(shù)和對象，當(dāng)前程序集（項目）及外部程序集（項目）都可以訪問

namespace RectangleApplication
{
    class Rectangle
    {
        public double length;
        public double width;
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("長度： {0}", length);
            Console.WriteLine("寬度： {0}", width);
            Console.WriteLine("面積： {0}", GetArea());
        }
        /* 成員變量及函數(shù)被聲明為 public，故可被所有函數(shù)及類的實例訪問 */
    }

    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

2、Protected Internal 訪問修飾符

允許在本類、派生類或者包含該類的程序集中訪問，用于實現(xiàn)繼承

3、Internal 訪問修飾符

允許一個類將其成員變量和成員函數(shù)暴露給當(dāng)前程序集中的其他函數(shù)和對象，外部程序集（項目）不可訪問

namespace RectangleApplication
{
    class Rectangle
    {
        internal double length;
        internal double width;
        /* 成員變量被聲明為 internal，故可被當(dāng)前程序集的函數(shù)訪問，不可被外部訪問 */
        
        double GetArea() // 成員函數(shù)聲明時不帶有任何訪問修飾符，默認為 private
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("長度： {0}", length);
            Console.WriteLine("寬度： {0}", width);
            Console.WriteLine("面積： {0}", GetArea());
        }
    }
    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

4、Protected 訪問修飾符

允許子類訪問它的基類的成員變量和成員函數(shù)，有助于實現(xiàn)繼承

5、Private 訪問修飾符

允許一個類將其成員變量和成員函數(shù)對其他的函數(shù)和對象進行隱藏，只有當(dāng)前類的成員函數(shù)可以訪問（類的實例不能訪問）

namespace RectangleApplication
{
    class Rectangle
    {
        private double length;
        private double width;
        /* 成員變量被聲明為 private，故可被當(dāng)前類的成員函數(shù)訪問，不可被類外訪問 */
        
        public void Acceptdetails()
        {
            Console.WriteLine("請輸入長度：");
            length = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("請輸入寬度：");
            width = Convert.ToDouble(Console.ReadLine());
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("長度： {0}", length);
            Console.WriteLine("寬度： {0}", width);
            Console.WriteLine("面積： {0}", GetArea());
        }
    }
    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

注：如果類成員沒有指定訪問修飾符，則默認為 private

十、方法

1、定義及調(diào)用方法

/* 定義方法的語法 */
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

// Access Specifier：訪問修飾符，聲明變量或方法對于另一個類的可見性
// Return type：方法返回的值的數(shù)據(jù)類型，若無返回值則類型為 void
// Method name：方法名稱，標(biāo)識符唯一，且大小寫敏感
// Parameter list：參數(shù)列表，用來傳遞和接收方法的數(shù)據(jù)
// Method body：方法主體，包含了完成任務(wù)所需的指令集

class NumberManipul
{
    /* 定義方法：訪問修飾符 public，返回類型 int，方法名 FindMax，以及參數(shù)和主體 */
    public int FindMax(int num1, int num2)
    {
        int result;
        /* 若if內(nèi)只執(zhí)行一條語句，可以省略花括號{} */
        if (num1 > num2)
            result = num1;
        else
            result = num2;
            
        return result;
    }
    
    static void Main(string[] args)
    {
        int a = 100;
        int b = 200;
        int ret;
        NumberManipul n = new NumberManipul(); // 實例化 NumberManipul 類
        ret = n.FindMax(a, b); // 調(diào)用 FindMax 方法
        Console.WriteLine("最大值是： {0}", ret );
        Console.ReadLine();
    }
}

2、遞歸函數(shù)

一個方法可以自我調(diào)用，這就是所謂的遞歸

class NumberManipulator
{
    public int factorial(int num)
    {
        int result;
        if (num == 1)
        {
            return 1;
        }
        else
        {
            result = factorial(num - 1) * num; // 調(diào)用自身并迭代參數(shù)以實現(xiàn)遞歸
            return result;
        }
    }
    
    static void Main(string[] args)
    {
        NumberManipulator n = new NumberManipulator();
        Console.WriteLine("6 的階乘是： {0}", n.factorial(6));
        Console.WriteLine("7 的階乘是： {0}", n.factorial(7));
        Console.WriteLine("8 的階乘是： {0}", n.factorial(8));
        Console.ReadLine();
    }
}

3、參數(shù)傳遞

• 按值傳遞參數(shù)（默認方式）

當(dāng)調(diào)用一個方法時，會為每個值參數(shù)創(chuàng)建一個新的存儲位置；實際參數(shù)的值會復(fù)制給形參，實參和形參使用的是兩個不同內(nèi)存中的值，所以，當(dāng)形參的值發(fā)生改變時，不會影響實參的值，從而保證了實參數(shù)據(jù)的安全

class NumberManipulator
{
    public void swap(int x, int y)
    {
        int temp;
        temp = x; // 保存 x 的值
        x = y; // 把 y 賦值給 x
        y = temp; // 把 temp 賦值給 y
    }
    
    static void Main(string[] args)
    {
        NumberManipulator n = new NumberManipulator();
        int a = 100;
        int b = 200;
        Console.WriteLine("在交換之前，a 的值： {0}", a);
        Console.WriteLine("在交換之前，b 的值： {0}", b);
        n.swap(a, b); // 調(diào)用函數(shù)來交換值
        Console.WriteLine("在交換之后，a 的值： {0}", a);
        Console.WriteLine("在交換之后，b 的值： {0}", b);
        Console.ReadLine();
    }
}

/* 結(jié)果表明，即使在函數(shù)內(nèi)改變了值，值也沒有發(fā)生任何的變化 */

• 按引用傳遞參數(shù)

引用參數(shù)是一個對變量的內(nèi)存位置的引用，它不會創(chuàng)建新的存儲位置，而是與實際參數(shù)具有相同的內(nèi)存位置，使用 ref 關(guān)鍵字聲明引用參數(shù)

class NumberManipulator
{
    public void swap(ref int x, ref int y)
    {
        int temp;
        temp = x; // 保存 x 的值
        x = y; // 把 y 賦值給 x
        y = temp; // 把 temp 賦值給 y
    }
    
    static void Main(string[] args)
    {
        NumberManipulator n = new NumberManipulator();
        /* ref參數(shù)需在傳遞前初始化變量 */
        int a = 100;
        int b = 200;
        Console.WriteLine("在交換之前，a 的值： {0}", a);
        Console.WriteLine("在交換之前，b 的值： {0}", b);
        n.swap(ref a, ref b); // 調(diào)用函數(shù)來交換值
        Console.WriteLine("在交換之后，a 的值： {0}", a);
        Console.WriteLine("在交換之后，b 的值： {0}", b);
        Console.ReadLine();
    }
}

/* 結(jié)果表明，swap 函數(shù)內(nèi)的值改變了，且這個改變可以在 Main 函數(shù)中反映出來 */

• 按輸出傳遞參數(shù)

輸出參數(shù)也是一個對變量的內(nèi)存位置的引用，它會把方法輸出的數(shù)據(jù)賦給自己，可從函數(shù)中返回兩個值，使用 out 關(guān)鍵字聲明輸出參數(shù)；提供給輸出參數(shù)的變量不需要賦值，而當(dāng)需要從一個未指定參數(shù)初始值的方法中返回值時，輸出參數(shù)特別有用

class NumberManipulator
{
    public void getValues(out int x, out int y)
    {
        /* out參數(shù)需在函數(shù)內(nèi)部初始化變量 */
        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); // 調(diào)用函數(shù)來獲取值
        Console.WriteLine("在方法調(diào)用之后，a 的值： {0}", a);
        Console.WriteLine("在方法調(diào)用之后，b 的值： {0}", b);
        Console.ReadLine();
    }
}

/* 獲取的結(jié)果完全取決于用戶輸入 */

十一、可空類型（Nullable）

1、Nullable 類型定義?

表示其基礎(chǔ)值類型正常范圍內(nèi)的值，再加上一個 null 值，用于對 int, double, bool 等數(shù)據(jù)類型進行 null 的賦值

/* 聲明一個 nullable 類型的語法 */
<data_type>? <variable_name> = null;

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();
    }
}

2、Null 合并運算符??

用于定義可空類型和引用類型的默認值，為類型轉(zhuǎn)換定義了一個預(yù)設(shè)值，以防可空類型的值為 Null；Null 合并運算符把操作數(shù)類型隱式轉(zhuǎn)換為另一個可空（或不可空）的值類型的操作數(shù)的類型，如果第一個操作數(shù)的值為 null，則返回第二個操作數(shù)的值，否則返回第一個操作數(shù)的值

class NullablesAtShow
{
    static void Main(string[] args)
    {
        double? num1 = null;
        double? num2 = 3.14157;
        double num3;
        num3 = num1 ?? 5.34; // 若 num1 為空則返回 5.34，否則返回 num1 的值
        Console.WriteLine("num3 的值： {0}", num3);
        num3 = num2 ?? 5.34; // 若 num2 為空則返回 5.34，否則返回 num2 的值
        Console.WriteLine("num3 的值： {0}", num3);
        Console.ReadLine();
    }
}

十二、數(shù)組（Array）

1、數(shù)組基礎(chǔ)

/* 聲明一個數(shù)組的語法 */
datatype[] arrayName;

// datatype：指定被存儲在數(shù)組中的元素的類型
// []：指定數(shù)組的秩（維度），秩指定數(shù)組的大小
// arrayName：指定數(shù)組的名稱

double[] balance; // 聲明數(shù)組
double[] balance = {2340.0, 4523.69, 3421.0}; // 聲明并賦值給數(shù)組

double[] balance = new double[10]; // 初始化一個長度為10的數(shù)組（元素為默認值）
balance[0] = 4500.0; // 通過索引號賦值給單個元素

int[] marks = new int[5]  {99,  98, 92, 97, 95}; // 創(chuàng)建并初始化一個數(shù)組
int[] marks = new int[]  {99,  98, 92, 97, 95}; // 省略數(shù)組長度的寫法
int[] score = marks; // 賦值一個數(shù)組變量到另一個數(shù)組變量中

2、數(shù)組細節(jié)

• 多維數(shù)組

string [,] names; // 聲明一個 string 變量的二維數(shù)組
int [,,] m; // 聲明一個 int 變量的三維數(shù)組

（未完待續(xù)）文章來源地址http://www.zghlxwxcb.cn/news/detail-733081.html

到了這里，關(guān)于【學(xué)習(xí)筆記】C#基礎(chǔ) - 由C/C++衍生出來的面向?qū)ο蟮木幊陶Z言的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！