?文章有誤請指正，如果覺得對你有用,，請點贊收藏關注一波,，謝謝支持??

提示：以下是本篇文章正文內容

C#

簡介

1. C#是微軟公司發(fā)布的一種由C和C++衍生出來的面向對象的編程語言，它不僅去掉了 C++ 和 Java 語言中的一些復雜特性,，還提供了可視化工具,，能夠高效地編寫程序。
2. C#是由C和C++衍生出來的一種安全的,、穩(wěn)定的,、簡單的、優(yōu)雅的面向對象編程語言,。它在繼承C和C++強大功能的同時去掉了一些它們的復雜特性（例如沒有宏以及不允許多重繼承）,。
3. C#使得C++程序員可以高效的開發(fā)程序，且因可調用由 C/C++ 編寫的本機原生函數(shù),，而絕不損失C/C++原有的強大的功能,。因為這種繼承關系，C#與C/C++具有極大的相似性,，熟悉類似語言的開發(fā)者可以很快的轉向C#,。

C#關鍵字

??C#初次體驗

?使用Visual Studio創(chuàng)建第一個項目 打印Hello world!

1.1 創(chuàng)建項目

打開VS->新鍵項目->找到控制臺程序（.NET Framework）->下一步->創(chuàng)建
eg:

1.2 打印Hello world!

??如何編譯當前程序,？

1.C#程序–人能看懂,，機器看不懂
2.執(zhí)行程序的確是機器
3.需要將C#程序編譯（翻譯）成機器能夠讀懂的語言（二進制）
4.這樣程序就可以被機器執(zhí)行了
5.Windows:生成->生成解決方案 Ctrl + Shift + B

??如何運行當前程序,？
1.Windows:運行而不調試（Ctrl + F5/F5）
eg:

??注釋
1.注釋是不會被編譯的，更不會被執(zhí)行
2.注釋的作用：
3.解釋說明當前的代碼是什么含義
?3.1,、強調
??1.在目前學習代碼階段,，保證你寫的每行代碼都要配一行注釋
??2.解釋說明，你這句代碼是什么含義
?3.1,、暫時取消某些代碼的執(zhí)行
??快捷鍵：
???注釋當前選中行的代碼:Ctrl + K + C
???取消注釋當前選中行的代碼:Ctrl + K + U

??MSDN

?MSDN地址

https://docs.microsoft.com/zh-cn/dotnet/api/system.reflection.fieldinfo?view=netframework-4.7.2

??數(shù)據(jù)類型

?數(shù)據(jù)的量級

• 1024字節(jié)（byte）=1KB
• 1024KB = 1MB
• 1024MB = 1GB
• 1024GB = 1TB
• 1024TB = 1PB

?數(shù)據(jù)類型

• bool 0000 0000 false 0000 0001 true
• sbyte 有符號的8位整數(shù) 000 0000 — 111 1111 （0-127）
  ?1.第一位表示符號（+ -）
  ?2.特殊0：1000 0000 和 0000 0000
  ?3.硬性規(guī)定：1000 0000 表示-128
  ?4.取值范圍：-128—+127
• byte無符號的8位整數(shù)
  ?1.0000 0000 —— 1111 1111
  ?2.取值范圍 0 ——255
• short有符號的16位整數(shù)（文檔中是Int16）
  ?1.000 0000 0000 0000 —— 111 1111 1111 1111
  ?2.負32768到正32767
• int有符號的32位整數(shù)（文檔中是Int32）
  • 最常用的整數(shù)類型
  • 一般說整型即int類型
  • 無特殊情況,，存儲一個整數(shù)都用int
  • int占4個字節(jié)（面試經(jīng)常問）
• long有符號的64位整數(shù)（文檔中是Int64）
• 浮點數(shù)（通常理解就是生活中的小數(shù)）
  • float（單精度浮點數(shù)）【文檔中查：Single】
    • 一般情況下，float足夠
  • double（雙精度浮點數(shù)）【文檔中查：Double】
    • 如果需要精度更高一點,，用Double
  • decimal（高精度浮點數(shù)）
    • 極少用到,，天文數(shù)字可能會用到這個

?常量、變量

• 程序運行期間
  • 程序開始到程序結束
• 變量：在程序運行期間,，可以被改變
  • 變量的聲明
    • 數(shù)據(jù)類型 變量名 = 初值;
    • ? int a = 10;
  • 變量可以不賦初值（在特殊情況下必須要賦初值）
    • 不賦初值時,，當前變量的值是默認值
      • int/float 默認值是0
      • char 默認值’\0’（表示空字符）
• 常量：在程序運行期間，不能被改變
  • 常量的聲明
    • const 數(shù)據(jù)類型 變量名 = 初值;
    • 大寫（潛規(guī)則）
    • ? const float money = 100.35f;
  • 常數(shù)必須要賦初值
• 浮點型聲明時注意：
  • float flo = 1.11f;【float數(shù)字后面要加f】
  • double damage = 1.11d【double后面要加d】
  • decimal damage = 1.223m【decimal后面要加m】
• 字符型聲明注意：
  • 字符類型(一定要用單引號括起來)
  • char cha = 'name’;
• 常量及變量的命名規(guī)則
  • 只能由字母,、數(shù)字,、@和下劃線(_)這些組成
  • 數(shù)字不能開頭，? 1a?,、3f?,、xiaoming1?
  • @符號，要么不用,，要用必須放在首位,，??@zhansan?,zhang@san?
  • 不能與系統(tǒng)的關鍵詞同名，? int,，long,，sbyte?
  • 變量名不能重復
  • 中文變量名語法上是可以的，但極為不推薦
• 常量及變量的命名規(guī)范
  • 全是英文單詞,，不要用拼音
  • 駝峰命名法
    • 大駝峰（每個單詞的首字母大寫,，其余字母小寫）
      • MyHeroDamage、HeroAttack
    • 小駝峰：（第一個單詞首字母不大寫,，后面每個單詞的首字母大寫,，其余字母小寫）
      • myHeroDamage、heroAttack【目前階段都用小駝峰】
• 見名知意
  • 永遠的神（你曉得這是啥,？評論區(qū)見）?

??運算符

?數(shù)據(jù)的量級

• 賦值運算符 “=”,，是一個運算，將后面的結果賦給前面的變量或常量
  • 前面 = 后面,；后面的值賦給前面
  • 前面必須是個變量【不能是具體是數(shù)值（2,，3，’A',“123”）】
  • 后面可以是具體的數(shù)值,，也可以是變量,，也可以是常量

?算術運算符

• +,、- 加減法
• *、/ 乘除法
  • a / b 運算之后得到一個結果
  • 被除數(shù) ÷ 除數(shù) = 商
  • 除法有一個禁忌：除數(shù)不能為0
• % 取余（做除法取余數(shù)）
  • 5 % 3 ： 5除以3,，得到的余數(shù),，是結果
• 上面的+、-,、*,、/、%都是二元運算符
• ++運算符和–運算符
  • 舉例：a++; 等價于 a = a+1;
  • ++,、- -是一元運算符

//int showYouAge = age++;//結果是18
   //意味著 age++ 得到的結果是 age
   //解析：
   //第一步：將age的值賦給showYouAge
   //第二步：age自增

int showYouAge = ++age;
    //意味著 ++age 得到的結果是 age+1
    //解析：
    //第一步：age自增
    //第二步：將age的值賦給showYouAge

//總結：
    //age++;++age;
    //++符號在前就先自增,，后賦值
    //++符號在后就先賦值，后自增

練習題:

?符合運算符

• a+=b;等價于a=a+b;
• a=a+4; ==> a+=4;
• a-=b;等價于a=a-b;
• a*=b;等價于a=a*b;
• a/=b;等價于a=a/b;
• a%=b;等價于a=a%b;

?輸入與輸出

• 輸出
  • Console.WriteLine();
    • 輸出內容,，并換行
  • Console.Write();
    • 輸出內容,，不換行
• 輸入
  • Console.Read();
    • 從屏幕讀取一個字符，并返回該字符所對應的整型數(shù)字
  • Console.ReadLine();
    • 從屏幕讀取一串字符,，并返回該字符串
    • 字符串是一個數(shù)據(jù)類型
      • 關鍵詞string
      • 表示一串字符
      • 用雙引號括起來
      • 字符串相加可以得到兩個字符串組合到一起的字符串

??預編譯執(zhí)行 region

• 作用：代碼分成一個區(qū)域,，方便折疊和展開
• 區(qū)域首部：#region
• 區(qū)域尾部：#endregion
  eg:
  

?類型轉換

• 隱式轉換
  • 將占用字節(jié)小的、取值范圍小的,、精度小的,，轉換為占用字節(jié)大的、取值范圍大的,、精度高
  • 不需要任何的修飾符,，會自動轉換

//整型
//1     2     4   8
//sbyte short int long
sbyte englishScore = 100;
//sbyte --> int
int myScore = englishScore;
//int --> long
long classScore = myScore;
//int --> float
float newScore = myScore;
//float --> double
double newClassScore = newScore;

• 顯式轉換（強制轉換）
  • 將占用字節(jié)大的、取值范圍大的,、精度高,，轉換為占用字節(jié)小的、取值范圍小的,、精度小的
  • 需要強制轉修飾符，會有精度的缺失,，甚至數(shù)據(jù)的錯誤
  • 轉換情況：知道這個數(shù)字,，在小的數(shù)據(jù)類型的取值范圍內

//強制轉換
int damage = 10000;
//int --> sbyte
sbyte health = (sbyte)damage;
//輸出結果
Console.WriteLine(health); //16

float mathScore = 90.5f;
//float --> int
int myAllScore = (int)mathScore;
//會把小數(shù)點后面的內容全部舍去
Console.WriteLine(myAllScore); //90

• int和char之間的類型轉換

//int 和 char之間的類型轉換
int num = 11101;
//int --> char
char letter = (char)num;
//a-97
Console.WriteLine(letter);

評論區(qū)請教大神！??！

• int和bool之間的類型轉換
  • 不能進行轉換
• string與其他類型之間的轉換
  • 舉例：
    • “false”，“true”
    • “10”,“3.14”
    • “A”
  • 轉換方法
    • System.Convert
      • System.Convert.ToBoolean()
      • System.Convert.ToInt32()
      • System.Convert.ToSingle()
      • System.Convert.ToDouble()
      • System.Convert.ToChar()
    • 數(shù)據(jù)類型.Parse()
      • int.Parse()
      • bool.Parse()
      • float.Parse()
      • char.Parse()
  • 其他類型能不能轉換成字符串
    • 其他類型的變量.ToString();

?關系運算符 & 邏輯運算符

• 關系運算符：>,，<,，>=，<=,，==,，!=
• 邏輯運算符：邏輯運算是bool與bool之間的運算
  • &：與運算
    • true & true : true
    • true & false : false
    • false & false : false
    • 總結：一假則假
  • |：或運算
    • true | true : true
    • true | false : true
    • false | false : false
    • 總結：一真則真
  • ?。悍沁\算
    • ! true : false
    • ! false : true
  • &&：短路與運算
    • 普通的&與運算，無論第一個條件是真是假,，都會繼續(xù)判斷第二條件
    • 短路與運算&&,，如果判斷第一個條件已經(jīng)是假，則不會繼續(xù)判斷第二個條件
  • ||：短路或運算
    • 普通的|與運算,，無論第一個條件是真是假,，都會繼續(xù)判斷第二條件
    • 短路或運算||，如果判斷第一個條件已經(jīng)是真,，則不會繼續(xù)判斷第二個條件
  • 短路&&,、||
    • 優(yōu)點：第一個條件已經(jīng)得知整個邏輯運算的結果，就不會去判斷第二個條件了
      • 節(jié)約了運算量
    • 缺點：如果判斷中帶有運算,，如果不進行第二個條件的判斷,，那第二個條件中的運算也不能執(zhí)行

練習：????????????

• 手動計算下列表達式的值和number的值，并編寫程序來驗證結果是否正確
  • ①number初值為6：number++ * ++number - number-- / --number
  • ②number初值為5：number++ > 3 | --number == 0
  • ③number初值為2：number-- > 2 && --number == 0
  • ④number初值為12：number++ > 10 && --number != 2 && number-- == 0 && ++number != 3
  • ⑤number初值為0：number++ > -1 || --number <= 2 && number-- != 10
  • ⑥number初值為0：number++ < -1 || (–number >= 2 && number-- != 10)【小括號優(yōu)先級最高】

??分支語句

?條件運算符

• 條件運算符（三元運算符）
  • 條件表達式 ? 結果a : 結果b
• if的第一種形式

if(條件表達式){
	語句1;
} 

• if的第二種形式

if (條件表達式)
{
  語句1;
}
else
{
  語句2;
} 

• if的第三種形式

if (條件表達式1)
{
  語句1;
}
else if (條件表達式2)
{
  語句2;
}
else
{
  語句3;
} 

• Switch
  • 如果case 冒號后面沒有任何語句,，可以不加break;
  • Switch（）括號中是可以允許添加浮點型變量的,，但不推薦
    • 浮點型是有誤差的
    • 浮點型一般不做等于的判斷
      • 企業(yè)面試題：有一個浮點數(shù)，判斷該浮點數(shù)是不是等于5

?循環(huán)語句

• while循環(huán)

while (條件表達式)
{
  //循環(huán)內容
} 

• break關鍵詞
  • 跳出本層循環(huán)（通常與if連用）
• continue關鍵詞
  • 結束本次循環(huán)(continue后面的代碼不再執(zhí)行),，進入下次循環(huán),。(通常與if連用)

練習：????????????

• 從鍵盤輸入一個算數(shù)運算式，使用if語句實現(xiàn)正確的算數(shù)運算,，并輸出運算結果
  • 例如：
    • 請輸入第一個數(shù)字：4
    • 請輸入運算符：+
    • 請輸入第一個數(shù)字：2
    • 計算結果為：6
• 輸入一個生日日期,輸出其星座.
  白羊座:3.21-4.19,金牛座:4.20-5.20,雙子座:5.21-6.21,巨蟹座:6.22-7.22
  獅子座:7.23-8.22,處女座:8.23-9.22,天秤座:9.23-10.23,天蝎座:10.24-11.22
  射手座:11.23-12.21,魔羯座:12.22-1.19,水瓶座:1.20-2.18,雙魚座:2.19-3.20
  • 例如：
    • 請輸入月：12
    • 請輸入日：21
    • 您是射手座

??數(shù)組

????一維數(shù)組的初始化

• 動態(tài)初始化
  • 數(shù)據(jù)類型[] 數(shù)組名=new 數(shù)據(jù)類型[數(shù)組長度];
    • 此時數(shù)組中每一個元素都是為默認值
      • int的默認值0
      • float的默認值0
      • bool的默認值false
      • char的默認值'\0’,，表示空字符
      • string的默認值''
  • 數(shù)據(jù)類型[] 數(shù)組名=new 數(shù)據(jù)類型[數(shù)組長度]{元素1,元素2…};
  • 數(shù)據(jù)類型[] 數(shù)組名=new 數(shù)據(jù)類型[]{元素1,元素2…};
• 靜態(tài)初始化
  • 數(shù)據(jù)類型[] 數(shù)組名={元素1,元素2…};

??數(shù)組的訪問

• 從0開始計數(shù)
• array.Length是數(shù)組的長度，只讀的,。
• 訪問數(shù)組時,，切記下標所對應的數(shù)組元素是存在的
  • 如果不存在，就會引發(fā)數(shù)組越界異常

??引用數(shù)據(jù)類型

• 數(shù)據(jù)類型
  • 值類型（存儲在棧內存）
    • 棧內存里存的是具體的值
    • 前面學習過的值類型
      • int,、float,、bool、char
  • 引用類型（存儲在堆內存）
    • 棧內存里存的是地址（堆內存的地址）
    • 目前學習過的引用類型
      • string（特例）,、數(shù)組

??遍歷數(shù)組

• 遍歷數(shù)組：訪問數(shù)組中的每一個元素

int[] array = { 1,8,4,8,7,45,456,789,78,76};

for (int i = 0; i < array.Length; i++)
{
 Console.WriteLine(i + ':' + array[i]);
}

????二維數(shù)組,、結構體、枚舉

????冒泡排序

• 思想：
  • 當前數(shù)組元素與后面的數(shù)字元素進行對比,，如果前大后小,，則進行交換
  • 每輪可以確定一個最大值在數(shù)組的末位，幾輪之后即可完成排序
  • 冒泡排序當然也可以從大到小排序,，那樣則前小后大進行交互
    代碼：

for (int i = 0; i < array.Length; i++)
{
    //立個flag,，表示判斷過程中是否發(fā)生了交換
    bool IsjiaoHuan= false;

    for (int j = 0; j < array.Length - i - 1; j++)
    {
        if (array[j] > array[j + 1])
        {
            //說明交換了
            IsjiaoHuan= true;
            //交換
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }

    if(!IsjiaoHuan)
    {
        //說明已經(jīng)排好序了，后面的輪次就沒有必要了
        break;
    }

    for (int m = 0; m < array.Length; m++)
    {
        Console.Write(array[m] + '\t');
    }

    Console.WriteLine();

}

Console.WriteLine('排序結束');

for (int m = 0; m < array.Length; m++)
{
    Console.Write(array[m] + '\t');
}

????二維數(shù)組的定義

• 數(shù)據(jù)類型[,] 數(shù)組名;

??int[,] array;

• 二維數(shù)組的初始化
  • 動態(tài)初始化
    • 數(shù)據(jù)類型[,] 數(shù)組名 = new 數(shù)據(jù)類型[第一維長度,第二維長度];

      ??int[,] arr= new int[50,3];

    • 數(shù)據(jù)類型[,] 數(shù)組名 = new 數(shù)據(jù)類型[,]{數(shù)組值};

      ??int[,] arr= new int[,]{{1,0,1},{3,0,5}};

  • 靜態(tài)初始化
    • 數(shù)據(jù)類型[,] 數(shù)組名 = {數(shù)組值};

      ??int[,] arr= {{1,0,1},{3,0,5}};

• 二維數(shù)組的元素訪問
  • 數(shù)組名[第一維下標,第二維下標]

    ?? arr[3,2]

  • 謹防數(shù)組越界
• 二維數(shù)組的長度
  • 總長度（二維數(shù)組的元素個數(shù)）
    • array.Length
  • 第一維的長度
    • array.GetLength(0)
  • 第二維的長度
    • array.GetLength(1)
• 二維數(shù)組的遍歷

for (int i = 0; i < heroData.GetLength(0); i++)
{
   for (int j = 0; j < heroData.GetLength(1); j++)
   {
       Console.Write(heroData[i,j] + '\t');
   }
   //換行
   Console.WriteLine();
}

• foreach迭代遍歷
  • 迭代遍歷是只讀的，不能修改

//foreach性能消耗要大一點,，所以能用for的盡量用for
foreach (var item in number)
{
    Console.WriteLine(item);
    //迭代遍歷是只讀的,，不能寫入
    //item = 1;
}

????枚舉類型

• 枚舉類型是一個自定義類型
• 枚舉類型是一個值類型
• 枚舉類型的創(chuàng)建

//裝備類型
enum EquipType
{
    Helmet = 100,//頭盔
    BodyArmor = 200,//防彈衣
    Knapsack,//背包
    Knife
}

• 枚舉類型變量的定義與使用

//定義一個枚舉類型的變量
EquipType myEquip = EquipType.Knapsack;
EquipType yourEquip = EquipType.Knapsack;
//判斷枚舉變量
if(myEquip == EquipType.BodyArmor) { }
switch (myEquip)
{
    case EquipType.BodyArmor:
        break;
    case EquipType.Helmet:
        break;
    case EquipType.Knife:
        break;
        //case EquipType.
    default:
        break;
}
//枚舉類型和整型之間的轉換
//枚舉類型可以強制轉換為整型
int num = (int)myEquip;
Console.WriteLine(num);
//整型可以強制轉換為枚舉類型
myEquip = (EquipType)200;
Console.WriteLine(myEquip);
//既然枚舉可以用整數(shù)去表示
Console.WriteLine(myEquip+2);

????結構體類型

• 結構體類型是自定義類型
• 結構體類型是值類型
• 結構體類型的創(chuàng)建

//學生類型
struct Student
{
    public string name;
    public char sex;
    public int age;
}

• 結構體類型變量聲明及字段賦值

//定義一個學生變量
Student xiaoming;
//學生結構內變量賦值
xiaoming.name = 'xiaoming';
xiaoming.age = 16;
xiaoming.sex = 'M';

• 結構體的構造函數(shù)
  • 結構體默認的構造函數(shù)，開發(fā)者不能創(chuàng)建默認構造（即無參構造）

public Student()
{
    
}

• 結構體的自定義構造函數(shù),，方便創(chuàng)建結構體變量時給字段賦值

//自定義構造函數(shù)
public Student(string n,char s,int a)
{
    //作用：快速給結構體字段賦初值
    //而且必須給每一個字段都賦初值
    name = n;
    sex = s;
    age = a;
}

• 初始化結構體變量

//有了自定義的構造函數(shù)后,，如何新建結構體變量
Student xiaogang = new Student('xiaogang','M',18);

????結構體練習題

eg:

#region 結構體、枚舉
//創(chuàng)建英雄裝備結構體,，包含名稱,，攻擊力加成，法術強度加成,，血量加成,，裝備類型
enum EquipType
{
   AD,
   AP,
   HP,
   Other
}
//英雄裝備
struct HeroEquip
{
   public string name;
   public float adAddition;
   public float apAddition;
   public float hpAddition;
   public EquipType equipType;

   public HeroEquip(string name, float adBuff, float apBuff, float hpBuff, EquipType equipType)
   {
       //給所有字段賦初值
       this.name = name;
       adAddition = adBuff;
       apAddition = apBuff;
       hpAddition = hpBuff;
       this.equipType = equipType;
   }
}

#endregion
#region 結構體、枚舉練習

//有5個裝備保存在結構體數(shù)組當中,，編程找出血量加成最高者
//對裝備數(shù)組按照攻擊力加成排序并使裝備按照攻擊力加成升序進行信息打印

HeroEquip wjzr = new HeroEquip(
   '無盡之刃', 100, 0, 50, EquipType.AD);
HeroEquip yxj = new HeroEquip(
   '飲血劍', 80, 0, 20, EquipType.AD);
HeroEquip ktkj = new HeroEquip(
   '狂徒鎧甲', 0, 0, 150, EquipType.AD);
HeroEquip dmj = new HeroEquip(
   '蘭德里的折磨', 20, 100, 0, EquipType.AD);


//聲明結構體數(shù)組存儲這些裝備
HeroEquip[] heroEquips = { wjzr, yxj, ktkj, dmj };

//設置初始血量最大值
float maxHPBuff = heroEquips[0].hpAddition;
//設置初始血量最大值的裝備名稱
string maxHPEquipName = heroEquips[0].name;

HeroEquip maxHPEquip = heroEquips[0];

       //找血量最大
       for (int i = 0; i<heroEquips.Length; i++)
       {
           if (maxHPBuff<heroEquips[i].hpAddition)
           {
               //更新最大值
               maxHPBuff = heroEquips[i].hpAddition;
               //更新最大值的裝備名稱
               maxHPEquipName = heroEquips[i].name;
           }

           //如果聲明結構體
           if (maxHPEquip.hpAddition<heroEquips[i].hpAddition)
           {
               maxHPEquip = heroEquips[i];
           }
       }

       Console.WriteLine('裝備列表中,，血量加成最高的裝備是\n'
            + maxHPEquip.name + ',最大值是'
            + maxHPEquip.hpAddition);
Console.Read();
#endregion

??????面向對象

??面向過程

• 重點關心解決問題的步驟
• 優(yōu)點：
  • 可以很清晰的看明白問題解決的步驟
  • 代碼的行數(shù)要少一些，性能消耗低一些
• 缺點：
  • 不易維護,、不易拓展,、不易復用

??面向對象

• 重點關心解決問題過程中參與的對象有哪些，分別有哪些特性和行為
• 優(yōu)點：
  • 易維護,、易拓展,、易復用
• 缺點：
  • 代碼是分散的，行數(shù)會多一些
  • 性能消耗要高一些

??類和對象

• 創(chuàng)建一個類

[訪問修飾符] Class 類名//大駝峰命名法

• 創(chuàng)建一個類的對象

類名 對象名;

• 類的類型是一個引用類的型
• 類的類型是一個自定義類型
• 一個對象在創(chuàng)建后,，需要進行實例化（初始化）才能使用

類名 對象名 = new 類名();

• 原理 : 對象在進行new操作后,，才分配了內存。
  
  • 字段
    • 描述類的特性
    • 要使用小駝峰命名法命名
    • 可以有初值
  • 幫助注釋
    • 幫助注釋也是一種注釋
    • 誰可以添加幫助注釋
      • 類
      • 方法
      • 字段
      • 屬性
    • 幫助注釋的優(yōu)點
      • 在使用類,、方法,、字段、屬性的時候,，可以在提示框中顯示幫助注釋的內容

• this關鍵詞
  • 表示當前對象
  • 如果沒有重名沖突,，可以不寫（省去）
• Random隨機數(shù)類
  • 第一步，先創(chuàng)建一個隨機數(shù)對象

Random random = new Random();

• 第二步,，調用隨機數(shù)對象的Next方法

  • 調用時要傳入兩個參數(shù),，即隨機數(shù)字的取值范圍
    - 如傳入的是4和8，則隨機數(shù)字范圍為4至7,，不包含8（這個方法就是這么寫的）
    - 即取值范圍為左閉右開，即[min,max)
    - 方法返回的結果即隨機到的數(shù)字,，需要用整型變量去接收

int num = random.Next(0,array.Length);

• 方法
  • 方法是描述一個類的某個特定行為
  • 一個方法盡量就完成一件小的事情
    • 如果要完成一件大事
      • 先定義一些方法,，完成這個大事拆分出來的小事
      • 最后在按照流程，在大事方法中調用這些小事的方法
  • 方法要用大駝峰命名法命名
  • 方法的創(chuàng)建

 [訪問修飾符] 返回值類型 方法名(參數(shù)列表)
 {
   //方法體
   //實現(xiàn)方法功能
   return 結果;//最終別忘了返回方法結果,，結果類型需與返回值類型保持一致
 }

• 方法的調用

對象名.方法名(參數(shù)列表);//無論有無參數(shù),，小括號都要存在

• return關鍵詞
  • 返回結果
  • 終止方法,，即return后面的語句不會執(zhí)行

????屬性、方法參數(shù)

??屬性

• 屬性命名方式使用大駝峰
• 在屬性訪問器內寫代碼,，切記一點
  • Get訪問器內不要寫讀取該屬性的語句
  • Set訪問器內不要寫寫入該屬性的語句
  • 否則,，會出現(xiàn)遞歸循環(huán)，死循環(huán)
  • 屬性簡寫：public string Name { get; set; } = “先生”;

??引用參數(shù)ref

• 添加了ref關鍵詞的參數(shù)
  • 傳遞的就不是值了
  • 而是地址
    • 而如果沒有賦初值,，是沒有地址的
    • 所以ref參數(shù)一定是個變量
    • 所以ref參數(shù)的實參一定是賦過初值
• 所以ref一般加在值類型參數(shù)的前面
• 使用應用參數(shù),，無論是形參還是實參前面都要加ref關鍵詞

??輸出參數(shù)out

• 添加了out關鍵詞的參數(shù)
  • 參數(shù)就成了一個輸出的通道
  • 離開方法之前形參必須賦值
  • 實參必須是一個變量
  • 傳遞的實參一般是值類型
• 使用輸出參數(shù)，無論是形參還是實參前面都要加out關鍵詞

?? 字符串

????StringBuilder,、重載,、遞歸

??StringBuilder

• 在System.Text命名空間下
  • 所以使用時，需要先引入這個命名空間

using System.Text;

• 如果不引入,，可以直接寫：

System.Text.StringBuilder strB = new System.Text.StringBuilder();

• 使用時,，先要new

StringBuilder stringB = new StringBuilder();

• 追加字符串

//追加字符串
stringBuilder.Append('天氣好晴朗');

• 什么時候用StringBuilder而不用string
  • 字符串需要經(jīng)常修改的時候

???方法的重載

• 同一個類里面，方法名一樣,，但參數(shù)不一樣
  • 參數(shù)的數(shù)據(jù)類型不一樣
  • 參數(shù)的個數(shù)不一樣
  • 參數(shù)的數(shù)據(jù)類型不一樣,，個數(shù)也不一樣
• 參數(shù)個數(shù)和類型都一樣，但返回值類型不一樣,，不能算做重載?

class Funs
{
  public string Fun(string a, string b)
  {
      return 'a+b';
  }
  public int Fun(int a, int b)
  {
      return a + b;
  }
}
Funs funs = new Funs();
int a = funs.Fun(1, 1);
string b = funs.Fun('2', '2');
string c = string.Format('{0},{1}', a, b);
Console.WriteLine(c);
Console.Read();

??遞歸

• 方法自己調用自己
• 多個方法之間來回調用
• 使用遞歸時一定要有出口
• 使用遞歸時,，一定概要慎重慎重再慎重…

???構造函數(shù)

• 執(zhí)行的時機
  • new對象()的時候調用
• 構造函數(shù)一般都是public
  • 因為一旦構造函數(shù)被設置為了private，那么外界就無法new這個
• 構造函數(shù)沒有返回值
  • 也不能寫返回值類型
• 構造函數(shù)的名字必須和類名保持完全的一致
• 構造函數(shù)是不能像普通方法一樣被直接調用的
• 關于系統(tǒng)會不會自動創(chuàng)建一個空參空方法體的構造給你
  • 如果一個類沒有構造函數(shù)
    • 那么系統(tǒng)會自動寫一個空參數(shù)空方法體的構造函數(shù)
  • 如果有構造函數(shù)
    • 那么系統(tǒng)就不會幫你自動創(chuàng)建
• 構造函數(shù)可以有參,、也可以無參
• 構造函數(shù)是可以重載的
  • 如果想在執(zhí)行當前構造函數(shù)之前,，先執(zhí)行其他的構造函數(shù)
    • 當前構造函數(shù)(…) : this(傳實參)

class Person
{
 private int age;
 private string name;

 public Person(int age)
 {
     this.age = age;
     Console.WriteLine(age);
 }
 public Person(string name) : this(18)
 {
     this.name = name;
     Console.WriteLine(name);
 }

 public Person(int age, string name) : this('xian')
 {
     Console.WriteLine('我是性別，年齡！');
 }
}

static void Main(string[] args)
{
 Person body = new Person(128, 'alll');

 Console.Read();
}

??????多態(tài)

?關于父類空參數(shù)構造函數(shù)的調用說明

• 首先,，先要明確一點
  • 子類在實例化的時候,，必會調用父類的構造函數(shù)
• 子類在聲明構造函數(shù)的時候，要想辦法調用父類的構造
  • 如果父類是空參數(shù)的構造函數(shù) : base()
    • 可以不寫:base()
    • 系統(tǒng)會默認調用父類的空參數(shù)構造
  • 如果父類是有參數(shù)的構造函數(shù),，那么一定概要通過:base的方式調用,，傳參
• 關于VS自動生成類構造函數(shù)
  • 右鍵類名
  • 點擊快速修復或重構
  • 點擊生成構造

public class Person
{
    public string name;

    public Person(string name)
    {
        this.name = name;
        Console.WriteLine(name);
    }

    public void Say()
    {
        Console.WriteLine('你在干什么！');
    }
}
public class Person1:Person
{
    public Person1(string name):base(name)
    {
    }
    public new void Say()
    {
        Console.WriteLine('弄啥呢,！');
    }
}
public class Person2:Person1
{
    public Person2(string name) : base(name)
    {
    }
    public new void Say()
    {
        Console.WriteLine('搞啥呢,！');
    }
}
static void Main(string[] args)
{
    Person p = new Person('1');
    p.Say();
    Person1 p1 = new Person1('2');
    p1.Say();
    Person2 p2 = new Person2('3');
    p2.Say();
    PersonFun(p2);
    Console.ReadLine();
}
public static void PersonFun(Person person)
{
    person.Say();
}

?子類方法的覆蓋

• 前提條件：父類中有一個public函數(shù)，子類中沒有該函數(shù)
  • 因為子類中并沒有該函數(shù),，所以調用必是父類的
• 前提條件：子類里已經(jīng)有了該函數(shù),，父類里面也有該函數(shù)
  • 此時，子類對象調用子類的該函數(shù),，父類對象調用父類的該函數(shù)
  • 這種子類函數(shù),，可以稱之為覆蓋
  • 子類在書寫該函數(shù)的時候，規(guī)范的寫法應該是：
    • [訪問修飾符] new 返回值類型 函數(shù)名(參數(shù)列表)
  • 覆蓋：子類也有該函數(shù)了,，以后調用的時候就調用子類的該函數(shù)

?子類方法的重寫【表現(xiàn)出多態(tài)】

• 如果父類想要子類可以重寫該函數(shù)
  • 那么父類的該函數(shù)必須是一個虛函數(shù)
  • [訪問修飾符] virtual 返回值類型 函數(shù)名(參數(shù)列表)
• 子類該怎么重寫
  • [訪問修飾符] override 返回值類型 函數(shù)名(參數(shù)列表)
• 重寫：把子類和父類的該函數(shù)都重新寫了一遍,，有的新的內容
  • 此時，子類的對象,，無論是不是轉換成了父類的類型,，都會執(zhí)行重寫后的該函數(shù)
• 關于VS自動生成類重寫函數(shù)
  • 右鍵類名
  • 點擊快速修復或重構
  • 點擊生成重寫

public class Person
{
   public string name;

   public Person()
   {
   }

   public Person(string name)
   {
       this.name = name;
   }

   public virtual void Say()
   {
       Console.WriteLine('我是父類的方法');
   }


}
public class Person1 : Person
{
   public Person1(string name)
   {
   }

   public override void Say()
   {
       Console.WriteLine('我是字類的方法');
   }
}
static void Main(string[] args)
{
   Person1 p1 = new Person1('我是字類');
   p1.Say();
   Person p = new Person1('我是父類');
   p.Say();

   Console.ReadLine();
}

??所有類的最終基類:Object

• 所以，所有類都可以重寫Object類中的虛方法
• Object的虛方法有三個：
  • Equals：描述對象與對象之間是否相等
  • GetHashCode：將一個對象編程一串數(shù)字
  • ToString：將一個對象轉換為一個字符串

??抽象方法

• 抽象方法的關鍵詞abstruct
  • abstruct 返回值類型(參數(shù)列表)
• 抽象方法必須要放在抽象類里面
• 抽象方法沒有方法體： [訪問修飾符] abstruct 返回值類型 方法名(形參列表);
• 抽象方法的訪問修飾符不能是private
• 抽象類即可以放抽象方法,，也可以放普通方法
• 抽象方法必須在子類中全部實現(xiàn)
  • 除非子類也是一個抽象類,，那么可以先不實現(xiàn)該抽象方法
• 抽象方法和虛方法最大的區(qū)別
  • 抽象方法必須其派生類中得以實現(xiàn)
  • 而虛方法不是一定要在其派生類去重寫
• 無論是虛方法還是抽象方法，子類進行了重寫【實現(xiàn)】
  • 那么子類的子類依舊可以繼續(xù)重寫
• 抽象類不能用sealed關鍵詞修飾
• 總結：override可以重寫哪些方法呢,？
  • 帶有virtual,、abstruct、override關鍵詞的方法

代碼：

//抽象類
public abstract class Person
{
    public void Fun(string name)
    {
        Console.WriteLine(name);
    }
    public abstract void Say();
}
public class Person1 : Person
{
    public override void Say()
    {
        Console.WriteLine('asd');
    }
}
static void Main(string[] args)
{

    Person1 a = new Person1();
    a.Say();
    Console.Read();
}

??sealed關鍵詞

• 密封類
  • sealed關鍵詞修飾的類稱之為密封類
  • 語法：sealed class 類名
  • 密封類是不能被別的類繼承的
• 密封方法
  • sealed關鍵詞修飾的重寫的方法,，稱之為密封方法
  • 語法：sealed override 返回值類型 方法名（參數(shù)列表）
  • 密封方法無法再次被其子類重寫

代碼：

public class Person
{
public virtual void Fun()
{
  Console.WriteLine(1);
}
}
public class Person1 : Person
{
public sealed override void Fun()
{
  Console.WriteLine(2);
}
}
public class Person2 : Person1
{
//這里報錯 因為續(xù)承的Person1是密封函數(shù)
public override void Fun()
{
  base.Fun();
}
}
static void Main(string[] args)
{

Person a = new Person1();
a.Fun();

Console.Read();

}

??靜態(tài)類

• 關鍵詞 static
• 靜態(tài)成員
  • 成員：字段,、屬性、方法
  • 靜態(tài)：跟對象沒有任何關系,，只跟類有關系
• 靜態(tài)成員在何時開辟的內存
  • 第一次訪問這個類的時候【第一次用到這個類的時候】
    • 比如：用這個類名去實例化一個對象
    • 比如：用這個類型去訪問一個靜態(tài)字段
• 靜態(tài)成員在何時釋放內存
  • 在程序結束的時候才會釋放
• 普通的實例成員,，每有一個對象，就有一個該成員
  • 而靜態(tài)成員,，跟對象沒有關系,，所以無論有多少個對象，靜態(tài)成員都只有一個
  • 例: 實例成員【name】,每有一個人,，就會有對應的一個名字
    • 而靜態(tài)成員【Population】,跟對象沒有關系,，無論有多少個實例對象,，人口數(shù)量只有一個
• 靜態(tài)方法中是不可以訪問非靜態(tài)的成員的
  • 不能訪問非靜態(tài)的字段,、屬性
  • 不能調用非靜態(tài)的方法
• 非靜態(tài)方法中是可以訪問靜態(tài)成員的
  • 能訪問靜態(tài)的字段,、屬性
  • 能調用靜態(tài)的方法
• 靜態(tài)方法是可以有重載
• 靜態(tài)類
  • 靜態(tài)的成員可以放在靜態(tài)類中，也可以放在非靜態(tài)類中
  • 靜態(tài)類中只能存在靜態(tài)成員,，不能存在非靜態(tài)的成員
  • 靜態(tài)類是不能進行實例化的
• 靜態(tài)構造函數(shù)
  • 只有一種寫法
    • static 類名()
  • 靜態(tài)構造函數(shù)必須無參數(shù)
  • 靜態(tài)構造函數(shù)在什么時候才會調用
    • 靜態(tài)構造函數(shù)在程序運行期間只會執(zhí)行一次
    • 在第一次訪問該類的時候調用
      • 用這個類去new一個對象
      • 用這個類去訪問某個靜態(tài)成員
      • 用這個類去調用某個靜態(tài)方法
  • 如果有繼承關系
    • 靜態(tài)構造函數(shù)的執(zhí)行順序是：
    • 先執(zhí)行子類的靜態(tài)構造,，再執(zhí)行父類的靜態(tài)構造
    • 先子后父
  • 靜態(tài)構造有什么作用
    • 一般用于對靜態(tài)成員進行初始化

代碼

class Person
{
    public static float age=88;
    public static void Fun()
    {
        Console.WriteLine('我是父靜態(tài)類！');
    }
    static Person()
    {
        Console.WriteLine('我是基靜態(tài)類,！');
    }
}

class Per : Person
{
    static Per()
    {
        Console.WriteLine('我是子靜態(tài)類！');
    }
}
static void Main(string[] args)
{
    Per p = new Per();
    Console.WriteLine();
    Console.ReadLine();
}

集合,、棧,、堆、隊列,、字典 ???????

1,、集合~范型（命名空間using System.Collections.Generic;）

1.1、ArrayList

代碼：

//實例化動態(tài)數(shù)組
ArrayList score = new ArrayList();
//向動態(tài)數(shù)組中添加元素
score.Add(90);
score.Add(85.5f);
score.Add('English:100');

int[] array = { 90,80,70 };
//向動態(tài)數(shù)組中批量添加元素
score.AddRange(array);
//向動態(tài)數(shù)組中插入元素
score.Insert(2, 'Math:80.5');
//刪除動態(tài)數(shù)組中的元素
score.Remove(85.5f);
//刪除的是單個約束,，如果動態(tài)數(shù)組中沒有該元素,，就忽略
score.Remove(90);
//根據(jù)下標移除動態(tài)數(shù)組中的元素
score.RemoveAt(0);

score.AddRange(new string[] { 'A', 'B', 'C', 'A' });
//批量刪除元素
score.RemoveRange(2, 3);
//如果數(shù)組中沒有該下標所對應的元素，則也會出現(xiàn)越界異常
Console.WriteLine(score[1]);
//數(shù)組元素翻轉
score.Reverse();	
//一般想要刪除某個元素,，會先進行判斷是否存在
bool containsA = score.Contains('A');
Console.WriteLine('containsA:' + containsA);
//判斷數(shù)組中是否包含某個元素
if(score.Contains('A'))
{
  score.Remove('A');
}
Console.WriteLine('Count:' + score.Count);
//給一個元素的值,，查該值在動態(tài)數(shù)組中的下標
Console.WriteLine('IndexOf:' + score.IndexOf(790));
score.Clear();

score.AddRange(new float[] { 1.1f,5.7f,4.5f,9.8f,3,2,1});
//從小到大排序
score.Sort();
//清空動態(tài)數(shù)組
//score.Clear();
Console.WriteLine('-------------');
for (int i = 0; i < score.Count; i++)
{
  Console.WriteLine(score[i]);
}
Console.WriteLine('-------------');
foreach (var item in score)
{
  Console.WriteLine(item);
}

1.2、List

代碼：

//初始化范型集合
List<int> list = new List<int>();

//添加元素
list.Add(200);
list.Add(250);
list.Add(280);
//批量添加元素
list.AddRange(new int[] { 1,3,5,6,7,9 });
//移除某個元素
list.Remove(280);
//通過下標移除某個元素
list.RemoveAt(0);
list.RemoveAt(0);
//批量刪除
list.RemoveRange(0, 3);
int index = list.IndexOf(9);
Console.WriteLine(index);
Console.WriteLine('-----------');
foreach (var item in list)
{
   Console.WriteLine(item);
}

2,、棧（Stack ）

• 說明：后進先出

代碼：
eg:非范型為例??

Object<=Stack stack = new Stack();
//進棧
stack.Push('我是第一個進去的');
stack.Push('我是第二個進去的');
stack.Push('我是第三個進去的');
//出棧
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Pop());
Console.Read();
//返回棧頂?shù)脑豍eek();

• 常用方法
  

• Stack.TryPeek(T) 方法

1. 返回一個值,，該值指示 Stack 的頂部是否有對象；如果有,，則將其復制到 result 參數(shù)。 不從 Stack 中刪除對象,。
2. public bool TryPeek (out T result);
3. 返回
   Boolean
   如果 Stack 的頂部有對象，則為 true,；如果 Stack 為空，則為 false,。

• Stack.TryPop(T) 方法

4. public bool TryPop (out T result);
5. 返回一個值，該值指示 Stack 的頂部是否有對象,；如果有,，則將其復制到 result 參數(shù)，并從 Stack 中刪除它,。
6. 返回
   Boolean
   如果 Stack 的頂部有對象,，則為 true；如果 Stack 為空,，則為 false,。

3、堆（heaps）

??????略略略

4,、隊列（Queue）

• 說明：先進先出
  eg：進列
  
  eg：出列
  
  代碼：
  eg:非范型為例??

Queue queue = new Queue();
//進列
queue.Enqueue('我是第一個進去的');
queue.Enqueue('我是第二個進去的');
queue.Enqueue('我是第三個進去的');
//出列
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Dequeue());
Console.Read();

常用方法:

5、字典（Dictionary<string,int>）

代碼：

Dictionary<string, int> dis = new Dictionary<string, int>();
dis.Add('我是第一個進去的', 1);
dis.Add('我是第二個進去的', 2);
dis.Add('我是第三個進去的', 3);
Console.WriteLine(dis.Values);
Console.WriteLine(dis.ContainsValue(2));
Console.WriteLine(dis.ContainsValue(3));
Console.Read();

6,、常見的接口

????????單例,、接口和范型

1、單例

• 如果一個對象在聲明時直接實例化【new】,。
• 在訪問這個類的時候調用
• 實例化的時間點最早,，在靜態(tài)構造之前就執(zhí)行了

2、接口

• 接口相比類,，最大的不同之處在于,，只有定義沒有實現(xiàn)
• 接口相當于一堆骨架，實現(xiàn)接口的類,，用于填充骨架上的肉
• 接口不能進行實例化,，只能被類或其他接口實現(xiàn)
• 如即繼承類，又實現(xiàn)接口時,，類要放在最前面,，接口放在后面
  eg:
  • class Person1:Person,jiankou1,jiekou2

2.1、接口和抽象類的對比

• 相同點
  • 兩者都不能被實例化
  • 兩者都包含了由其他類或結構繼承或實現(xiàn)的抽象成員不同點
• 不同點
  • 抽象類當中除了擁有抽象成員外還可以擁有非抽象成員,；而接口中所有的所有成員都是抽象的
  • 抽象成員可以使用修飾符修飾,，接口當中接口成員訪問級別是默認不可修改的，并且默認是public
  • 接口當中不可以包含構造方法,，析構方法,，靜態(tài)成員以及常量
  • C＃類只支持單繼承，接口支持多支持

3,、范型

• 范型類的構造函數(shù)不用寫范型類
• 有些時候重載的方法只有參數(shù)類型不同,，其他的都一樣，這時就可以使用泛型,。
• 泛型：需要用戶自己傳過來的一個數(shù)據(jù)類型
• 平時方法里傳遞的是參數(shù),，是變量，參數(shù)傳遞用的是小括號（）,。
  而泛型傳遞的是數(shù)據(jù)類型,，泛型傳遞用的尖括號＜＞
• 泛型定義之后,，一定要用，不然就沒有意義
  • 泛型都在方法的哪里用,？
    • 定義參數(shù)
    • 在方法體呢使用泛型定義局部變量口
    • 設置返回值類型是一個泛型,。給泛型添加約束
• 給范型舔加約束
  • 方法名（參數(shù)列表）where 泛型：約束內容
  • 方法名（參數(shù)列表）where 泛型A：約束內容1，約束內容2 where 泛型B：約束內容3
• 關于泛型方法的重載
  • 如果泛型的個數(shù)不同,，可以重載
  • 如果泛型的個數(shù)相同,，但約束不同，不可以重載
• 關于泛型類和泛型接口
  • class 類名<T,F>
    • 類中的字段類型,、方法參數(shù)、方法返回值,，都可以使用類中的泛型
  • interface 接口名< T >
    

代碼：

public class fanxing
{
  
}
public static void FX<T>(T sex, T age)
{
   T temp = sex;
   sex = age;
   age = temp;
   Console.WriteLine(age);
}
public static void FX<T>(T sex, T age, T a)
{
   T temp = sex;
   sex = age;
   age = temp;
   Console.WriteLine(age);
}

static void Main(string[] args)
{
  FX<int>(7,8);
  FX<float>(7,8);
   Console.ReadLine();
}
- 范型方法的范型重載
eg 代碼：
```代碼
public static void faning<T>()
{

}
public static void faning<T,F>()
{

}
public static void faning<T,F,U>()
{

}

static void Main(string[] args)
{
   faning<>

}

????????委托與事件

1,、委托（delegate）

2.1常見委托類型

• 什么是委托：相當于中介
• 委托的別名：代理、句柄
• 委托是自定義類型
• 委托是引用類型

代碼eg：
eg:非范型為例??

//定義委托
delegate void weituo(float momey);
class p1
{
	public void zhao1(float momey)
    {
		Console.WriteLine('中介一需要:'+momey+'$');
    }
	public void zhao2(float momey)
	{
		Console.WriteLine('中介二需要:'+ momey + '$');
	}
	public void zhao3(float momey)
	{
		Console.WriteLine('中介三需要:'+ momey + '$');
	}
	public void zhao4(float momey)
	{
		Console.WriteLine('中介四需要:'+momey + '$');
	}
}

internal class Program
{
	static void Main(string[] args)
	{
		p1 p = new p1();

		weituo we;

		we = p.zhao1;
		we += p.zhao2;
		we += p.zhao3;
		we += p.zhao4;
		we(1232143);
		Console.Read();
	
	}
}

2.2系統(tǒng)委托類型

1. 無返回值系統(tǒng)委托 Action<>

代碼eg：
eg:??

class p1
{
	public void wcs()
	{
		Console.WriteLine('我是無參數(shù)的中介需要:' + '18456456456456'+ '$');
	}
	public void zhao1(float momey)
    {
		Console.WriteLine('中介一需要:'+momey+'$');
    }
	public void zhao2(float momey)
	{
		Console.WriteLine('中介二需要:'+ momey + '$');
	}
	public void zhao3(float momey)
	{
		Console.WriteLine('中介三需要:'+ momey + '$');
	}
	public void zhao4(float momey)
	{
		Console.WriteLine('中介四需要:'+momey + '$');
	}
}

internal class Program
{
	static void Main(string[] args)
	{
		p1 p = new p1();
		//使用系統(tǒng)委托
		//無參數(shù)
		Action action;
		action = p.wcs;
		action();

		//參數(shù)
		Action<float> action1;
		action1 = p.zhao1;
		action1 += p.zhao2;
		action1 += p.zhao3;
		action1 += p.zhao4;
		action1(182);
		Console.Read();
	}
}

2. 有返回值系統(tǒng)委托 Func<>

代碼eg：
eg:??

class Hout
{

}
class p1
{
	public string Func1()
	{
		return '有返回值函數(shù)無參數(shù):';
	}

	public Hout Func2(string name)
	{
		Console.WriteLine('有返回值函數(shù)有參數(shù):'+name);
		return null;
	}

}

internal class Program
{
	static void Main(string[] args)
	{
		p1 p = new p1();

		Func<string> func;

		func = p.Func1;

		Console.WriteLine(func());


		Func<string,Hout> func1;

		func1 = p.Func2;

		Hout a= func1('先生');

		Console.Read();
	}
}

2.3委托之匿名函數(shù)

代碼eg：
eg:??

class p1
{
	public Action<string> action;
	public string name;
	public int age;

    public p1(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

	public void isAction(string age)
    {
        Console.WriteLine('我是個中介:'+ age);
        if (action != null)
        {
            action(age);
            Console.WriteLine('我是個中介:' + age);
        }
    }
}

internal class Program
{
	static void Main(string[] args)
	{
        p1 p = new p1('先生',18);

        p.action = delegate (string a)
        {
            Console.WriteLine(a);
            Console.WriteLine('我好蒙啊2');
        };
        p.action += read;

        p.isAction('我好蒙啊1');

        Console.Read();
	}
    public static void read(string name)
    {
        Console.WriteLine(name);
        Console.BackgroundColor = ConsoleColor.Red;
        Console.ForegroundColor = ConsoleColor.Black;
    }
}

???如何使用VS進行程序調試

• 程序是從Main函數(shù)開始,，順序執(zhí)行的
• 調試就是在你覺得可能會發(fā)生問題的地方打下斷點
  • 什么是斷點,？
    • 讓程序執(zhí)行到這個地方暫停下來的點
  • 有什么好處，可以一句句或一段段讓程序執(zhí)行
• 調試步驟
  • 給想要暫停的代碼行添加斷點
  • 開始調試
  • 通過監(jiān)視或局部變量窗口,，去看此時你想觀察的變量的值
  • 如果想看變量or對象的內存地址
    • 找到即時窗口
    • &變量名

總結