#region 折叠块名字
... //代码
#endregion

#define  //定义一个符号，类似一个没有值的变量
#undef //取消define定义的符号，让其失效

//两者都是写在脚本文件最前面
//一般配合if指令使用或配合特性

#if
#elif  //即elseif
#else
#endif
//和if语句规则一样，一般配合#define定义的符号使用
//用于告诉编译器进行编译代码的流程控制

#warning
#error
//告诉编译器是报警告还是报错误
//一般还是配合if使用

#define tag1
#define tag2
#undef tag2

#if tag1
    Console.WriteLine("Hello world!");  //执行
#elif tag2
    Console.WriteLine("Hi world!");     //不执行
#else 
    Console.WriteLine("Exit!");
#endif

Console.Write("xxx"); // 打印，不自动空行
Console.WriteLine("xxx"); // 打印，自动空行
Console.ReadLine(); //等待直到用户按下回车，一次读入一行。
Console.ReadKey();  // 等待用户按下任意键，一次读入一个字符。

Console.ReadKey(true).KeyChar; 
//Console 类的一个静态方法，它读取当前控制台上的任意键盘输入。参数 true 表示在读取输入后不显示读入的字符，如果是 false 则会显示读入的字符。
//返回值是 ConsoleKeyInfo 类型，包含了该字符的 KeyChar 属性（即按下的按键字符），以及关于按键是否有控制字符等其他信息。

Console.KeyAvailable //判断有无键盘输入，如果有则为true

//1.清空
Console.Clear();  

//2. 设置控制台大小
//注意：
//1.先设置窗口大小，在设置缓冲区大小
//2.缓冲区大小不能小于窗口大小
//3.窗口大小不能大于控制台的最大尺寸
Console.SetWindowSize(50,40);  // 设置窗口大小
Console.SetBufferSize(1000, 1000); // 设置缓冲区大小（可打印内容区域的宽高）

//3.设置光标的位置
//控制台左上角为原点，右侧是x轴正方向，下方是Y轴正方向，它是一个平面二维坐标系
//注意:
//1.边界问题
//2.横纵距离单位不同 1y = 2x 视觉上的
Console.SetCursorPosition(10,5);

//4.设置颜色相关
//文字颜色设置
Console.ForegroundColor = ConsoleColor.Red;
//背景颜色设置
Console.BackgroundColor = ConsoleColor.White;

//5.光标显隐
Console.CursorVisible = false;

//6.关闭控制台
Environment.Exit(0);

static void Main(string[] args)
{
    string str = @"C:\Users\22625\Desktop\1.txt";
    //快速获得文件名，输出：1.txt
    Console.WriteLine(Path.GetFileName(str));
    //只获得扩展名，输出：.txt
    Path.GetExtension(str);
    //不包含扩展名，输出：1
    Path.GetFileNameWithoutExtension(str)
   	//文件目录，输出：C:\Users\22625\Desktop
   	Path.GetDirectoryName(str);
    //文件全路径
    Path.GetFullPath(str);
    //链接两个字符串作为路径
    Path.Combine(@"C:\Users\22625\Desktop\","1.txt")
    ......
}

// 一般情况下，我们不会频繁调用、
// 都是在Loading过场景时，才调用
CG.Collect();

//double->int 强制类型转换（显式类型转换）
double a =(int)b;

//如果n1/n2有一个是double类型则整个式子提升为double类型：
//全int：输出结果d=3
int n1 = 10;
int n2 = 3;
double d = n1 / n2;
Console.WriteLine(d);

//将n1改为double类型：输出d=3.333...
double d = n1*1.0 / n2;  //n1*1.0将n1转换为double类型
Console.WriteLine(d);

string a = "123";  //但是只能转换int，如果a=”123abc“或“6.5”则会异常
int b = Convert.ToInt32(a);
Console.WriteLine(b);

string a = "123"; 
int b = int.Parse(a);
//double b = double.Parse(a)

int a = 0;
bool b = int.TryParse("123", out a);
//尝试将”123“转换为int类型，如果成功就将转换后的123赋值给a，并返回true给b。如果失败则返回false给b，a赋值为0。
Console.WriteLine(b);
Console.WriteLine(a);

int a = 123;
System.Int32 b = 123;

 public struct Person
{
    public string _name;  //字段前要加_，用来区分变量
    public int _age;
    public char _gender;
    
    void Speak()
    {
    ...
    }
}

// 字符串本质是char数组
string str = "test";
Console.WriteLine(str[0]);

// 转为char数组
char[] chars = str.ToCharArray();
Console.WriteLine(chars[0]);

// 尽管搜索方向不一样，但是字符下标依然从左向右加1，从0开始。

// 正向查找字符位置 从左到右
string str = "这是一句话";
int index1 = str.IndexOf("是");  //返回字符"e"在字符串中的索引，若查不到则返回-1

// 反向查找字符位置 从右到左
int index2 = str.LastIndexOf("是");

string str = "这是一句话";

//单参数
str = str.Remove(2);  //注意string的很多方法不会改变原字符串，都要存在一个新的字符串中或者重新赋值
Console.WriteLine(str);
//输出：这是


//指定两个参数进行移除
str = str.Remove(1,3);
Console.WriteLine(str);
//输出：这话

string str = "这是一句话";
str = str.Replace("一句话", "歌词");
Console.WriteLine(str);
//输出：这是歌词

string str = "abcdefg";
str = str.ToUpper();  //转大写
Console.WriteLine(str);
//输出ABCDEFG

str = str.ToLower();  //转小写

string str = "abcdefg";

//截取从指定位置开始之后的字符串
//单参数
str = str.Substring(2);
//输出cdefg

//双参数指定范围
str = str.Substring(1,3);
//输出bcd

string str = "a|b|c|d|e|f|g";

string[] strs = str.Split(new char[] { '|' }); //指定切割符号
for(int i = 0; i < strs.Length; i++) 
{
    Console.WriteLine(strs[i]);
}


//输出：
a
b
c
d
e
f
g

// 上文讲过的里氏替换
Father f = new Son();
if (f is Son)
{
    (f as Son).Speak();
}

//使用object类
//引用类型
object o = new Son();
if (o is Son)
{
    (o as Son).Speak();
}

//值类型
object o2 = 10.0f;     //装箱
float f2 = (float)o2;  //拆箱，强转

//string
object ostr = "123123";
string str1 = ostr.ToString();
string str2 = ostr as string; //建议引用类型都用as的方式

//数组
object oarr = new int[10];
int[] arr1 = (int[])oarr;
int[] arr2 = oarr as int[];


public class Father
{
    
}

public class Son : Father
{
    public void Speak()
    {
        Console.WriteLine("Hello world!");
    }
}

const 变量类型 变量名 = 值
const int a = 1；

//1. 创建能够产生随机数的对象
Random r = new Random();
//2. 让产生随机数的这个对象调用方法来产生随机数
r.Next(); //生成一个非负的随机数  
r.Next(100); //生成[0,99)的随机数  
r.Next(5,100); //生成[5,99)的随机数

// 声明枚举
public enum 枚举名
{
    值1, //默认值为0，后面依次递增
    值2,
    值3,
    ......
    值n  //最后一个逗号可加可不加
}

namespace ConsoleApp1
{
    enum EPlayer
    {
        singer,
        writer,
        teacher,
        student
    }
    
    internal class Program
    {
        static void Main(string[] args)
        {
            EPlayer Player1 = EPlayer.singer; //定义枚举变量
            
            switch (Player1)
            {
                case EPlayer.singer:
                    ...
                    break;
                case EPlayer.student:
                    ...
                    break;
                default:
                    break;
            }
        }
    } 
}

EPlayer Player = EPlayer.singer;  
// 枚举转int  
int i = (int)Player;  
// int转枚举  
Player = 0;  
// 枚举转string  
string str = Player.ToString();  
// string转枚举  
Player = (EPlayer)Enum.Parse(typeof(EPlayer), "teacher"); // 注意第二个变量值必须是枚举声明中的成员

int[] nums;  //只声明不初始化
int[] nums = new int[5]; //全部为默认值0

// 以下方式等价
int[] nums = new int[]{1,2,3,4,5};
int[] nums = new int[5]{1,2,3,4,5};
int[] nums = {1,2,3,4,5};

int len = nums.Lenght()  //数组长度

//增加数组中的元素
int[] array = { 1, 2, 3, 4, 5 };
int[] array1 = new int[10];
for (int i = 0; i < array.Length; i++)
{
    array1[i] = array[i];
}
array = array1;  //最后将新数组赋值给旧数组

//遍历打印array结果为
//1，2，3，4，5，0，0，0，0，0

//j减少数组中的元素
int[] array = {1,2,3,4,5,6,7,8,9,10};
int[] array2 = new int[5];
for (int i = 0; i < array2.Length; i++)
{
    array2[i] = array[i];
}
array = array2;

//遍历打印array结果为
//1，2，3，4，5

int[,] nums;  //只声明不初始化
int[,] nums = new int[3,3]; //全部为默认值0

// 以下方式等价
int[,] nums = new int[,]{{1,1,1},
                           {2,2,2},
                           {3,3,3}};
                           
int[,] nums = new int[3,3]{{1,1,1},
                           {2,2,2},
                           {3,3,3}};
                           
int[,] nums = {{1,1,1},
               {2,2,2},
               {3,3,3}};

nums.GetLength(0) //获取行数
nums.GetLength(1) //获取列数

int[][] arr1;
int[][] arr2 = new int[3][];


int[][] arr3 = new int[][]
            {
                new int[] { 1 },
                new int[] { 1, 2 },
                new int[] { 1, 2, 3 }
            };
            
int[][] arr4 = new int[3][]
            {
                new int[] { 1 },
                new int[] { 1, 2 },
                new int[] { 1, 2, 3 }
            };
            
int[][] arr5 = 
            {
                new int[] { 1 },
                new int[] { 1, 2 },
                new int[] { 1, 2, 3 }
            };

ArrayList array = new ArrayList();

//增
array.Add(1); //添加单个元素：list.Add();
array.Add(2.1);
array.Add(true);
array.Add("张三");

array.AddRange(new int[] { 1, 2, 3, 4, 5 });  //添加集合：list.AddRange();
array.insert(1,"李四"); //插入指定位置

//删
array.Remove("张三"); //指定删除单个元素
array.RemoveAt(0); //根据指定位置单个元素
array.RemoveRange(0，n); //（从下标0开始删除n个）
array.Clear(); //清空所有元素

//查
array[0];  //按下标查找
array.Contains("张三"); //查看元素是否存在

// 尽管搜索方向不一样，但是字符下标依然从左向右加1，从0开始。
array.IndexOf("张三");      //从左往右查找，找到返回下标，找不到返回-1
array.LastIndexOf("张三");  //从右往左查找，找到返回下标，找不到返回-1

//改
array[0] = "李四"; //通过下标改
array.Sort(); //升序排列
array.Reverse(); //反转

array.Count;   //元素数量

//使用迭代器遍历
foreach (var item in array)
{
    Console.WriteLine(array[item]);
}

Stack stack = new Stack();

//压栈  
stack.Push("1");  
  
//出栈  
stack.Pop();

//查
//栈无法查看指定位置的元素,只能查看栈顶的内容  
s = stack.Peek(); //注意只是查看，不是出栈  
stack.Contains("1"); //查看元素是否存在于栈中  
stack.Count; //栈的长度

//改
stack.Clear(); //清空栈  

//栈不能使用[]访问，所以无法使用for循环遍历，一般使用foreach
foreach (var item in stack)
{
    Console.WriteLine(item);
}

//另一种方式
//将队列转换为object数组
object[] array = stack.ToArray();
for(int i =0;i<array.Length;i++)
{
    Console.WriteLine(array[i]);
}

//循环出栈
while (stack.Count>0)
{
    object p = stack.Pop();
}

Queue queue = new Queue();

//入队
queue.Enqueue("1");   、
//出队
queue.Dequeue();

//查
queue.Peek();  //查看队列头元素但不会移除  
queue.Contains("1"); //查看队列中是否包含某个元素  
queue.Count;//队列长度  

//改
queue.Clear();  //清空队列  

//队列不能使用[]访问，所以无法使用for循环遍历，一般使用foreach
foreach (var item in queue)
{
    Console.WriteLine(item);
}

//另一种方式
//将队列转换为object数组
object[] array = queue.ToArray();
for(int i =0;i<array.Length;i++)
{
    Console.WriteLine(array[i]);
}

//循环出队
while (queue.Count > 0)  
{  
    object v5 = queue.Dequeue();  
}

Hashtable hashtable = new Hashtable();

//增：键不能相同  
hashtable.Add(1, "value1");  
hashtable.Add("key", "value2");  
hashtable.Add(true, "value3");、

//删
hashtable.Remove(1);   //根据键删除  
hashtable.Clear();

//查
hashtable["2"];  //根据键查找值，如果键不存在，返回 null  
hashtable.ContainsKey("key");  //判断是否包含某个键  
hashtable.ContainsValue("value4");  //判断是否包含某个值  
hashtable.Count; //获取键值对数量  

//改
hashtable["key"] = "value4";  //根据键修改

//遍历所有键
ICollection keys = hashtable.Keys;  //获取键的集合
foreach (var item in keys) 
{
    Console.WriteLine(item);
}

//遍历所有值
ICollection values = hashtable.Values; //获取值的集合
foreach (var item in values)
{
    Console.WriteLine(item);
}

//键值对一起遍历
foreach (DictionaryEntry item in hashtable)
{
    Console.WriteLine(item.Key + ":" + item.Value);
}

//迭代器遍历
IEnumerator enumerator1 = hashtable.GetEnumerator();
while (enumerator1.MoveNext())
{
    DictionaryEntry item = (DictionaryEntry)enumerator1.Current;
    Console.WriteLine(item.Key + ":" + item.Value);
}

IDictionaryEnumerator enumerator2 = hashtable.GetEnumerator();
while (enumerator2.MoveNext())
{
    Console.WriteLine(enumerator2.Key + ":" + enumerator2.Value);
}

List<int> list = new List<int>();

//增

list.Add(1);//添加单个元素
list.AddRange(new int[] { 2, 3, 4 });//添加集合
list.Insert(1, 66);//插入指定位置

//删
list.Remove("张三"); //指定删除单个元素
list.RemoveAt(0); //根据指定位置单个元素
list.RemoveRange(0，n); //（从下标0开始删除n个）
list.Clear(); //清空所有元素

//查
list[0];  //按下标查找
list.Contains(1); //查看元素是否存在
list.Count;   //list长度
// 尽管搜索方向不一样，但是字符下标依然从左向右加1，从0开始。
list.IndexOf(1);      //从左往右查找，找到返回下标，找不到返回-1
list.LastIndexOf(1);  //从右往左查找，找到返回下标，找不到返回-1

//改
list[0] = 1; //通过下标改
list.Reverse(); //反转

//使用迭代器遍历
foreach (var item in list)  
{  
    Console.WriteLine(item);  
}  
  
//for循环遍历  
for (int i = 0; i < list.Count; i++)  
{  
    Console.WriteLine(list[i]);  
}

list.Sort(); //升序排列

class Item : IComparable<Item> //继承IComparable接口
{
    public int money;
    
    public Item(int money)
    {
        this.money = money;
    }

    public int CompareTo(Item other)  //实现接口的方法
    {
        //返回值的含义
        // <0：放在传入对象的前面
        // =0：保持当前的位置不变
        // >0：放在传入对象的后面
        
        //可以简单理解传入对象的位置就是0
        //返回负数就放在它的左边，也就是前面
        //返回正数就放在它的右边，也就是后面
        
        //以下实现类的升序排序
        if (this.money > other.money) //如果当前对象的money大于传入对象的money
        {
            return 1; //返回正数，放在传入对象的后面
        }
        else if (this.money == other.money) //如果当前对象的money等于传入对象的money
        {
            return 0; //返回0，保持当前位置不变
        }
        else //如果当前对象的money小于传入对象的money
        {
            return -1; //返回负数，放在传入对象的前面
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        //自定义类的排序
        List<Item> itemList = new List<Item>();
        
        itemList.Add(new Item(10));
        itemList.Add(new Item(25));
        itemList.Add(new Item(13));
        itemList.Add(new Item(40));
        itemList.Sort();
        
        for(int i =0;i<itemList.Count;i++)
        {
            Console.WriteLine(itemList[i].money);
        }
    }
}

//输出
//10
//13
//25
//40

class Item
{
    public int money;
    
    public Item(int money)
    {
        this.money = money;
    }
}


class Program
{
    static void Main(string[] args)
    {
        //自定义类的排序
        List<Item> itemList = new List<Item>();
        
        itemList.Add(new Item(10));
        itemList.Add(new Item(25));
        itemList.Add(new Item(13));
        itemList.Add(new Item(40));
        itemList.Sort(SortItem);   //传入一个委托,委托的参数为两个对象,返回值为int
        // 也可以使用匿名函数简化
        // itemList.Sort((Item a, Item b) => {  if (a.money > b.money)
        //     {
        //         return 1;
        //     }
        //     else if (a.money == b.money)
        //     {
        //         return 0;
        //     }
        //     else
        //     {
        //         return -1;
        //     }     });  
        
        for(int i =0;i<itemList.Count;i++)
        {
            Console.WriteLine(itemList[i].money);
        }
        
        //以下实现类的升序排序
        static int SortItem(Item a, Item b)
        {
            //传入的两个对象为列表中的两个对象
            //进行两两的比较,用左边的和右边的条件比较
            //返回值规则和之前一样, 0做标准,负数在左（前),正数在右（后)
            if (a.money > b.money)
            {
                return 1;
            }
            else if (a.money == b.money)
            {
                return 0;
            }
            else
            {
                return -1;
            }    
        }
    }
}

//输出
//10
//13
//25
//40

Dictionary<int,string> dictionary = new Dictionary<int, string>();

//增：键不能相同  
dictionary.Add(1, "one");

//删：根据键删除 
dictionary.Remove(1);
dictionary.Clear();

//查
string v1 = dictionary[1];  //通过建获取值如果，不存在会抛出异常

//通过TryGetValue获取值
string v2;
if (dictionary.TryGetValue(1, out v2))
{
    //存在
}

dictionary.ContainsValue("one")  //判断是否包含某个键  
dictionary.ContainsKey(1)  //判断是否包含某个值  
dictionary.Count  //获取键值对数量  

//改
dictionary[1] = "ONE";  //根据键修改

//遍历所有键
foreach (int key in dictionary.Keys)
{
    Console.WriteLine(key);
}

//遍历所有值
foreach (string value in dictionary.Values)
{
    Console.WriteLine(value);
}

//键值对一起遍历
foreach (KeyValuePair<int, string> item in dictionary)
{
    int key = item.Key;
    string value = item.Value;
}

//迭代器遍历
IEnumerator<KeyValuePair<int, string>> enumerator = dictionary.GetEnumerator();
while (enumerator.MoveNext())
{
    KeyValuePair<int, string> item = enumerator.Current;
    int key = item.Key;
    string value = item.Value;
}

LinkedList<int> linkedList = new LinkedList<int>();  
LinkedListNode<int> first = linkedList.First; //获取头节点  
LinkedListNode<int> last = linkedList.Last; //获取尾节点  
  
//增  
linkedList.AddLast(1); //尾部添加  
linkedList.AddFirst(2); //头部添加  
linkedList.AddAfter(first, 3); //指定节点后添加  
linkedList.AddBefore(first, 4); //指定节点前添加  
  
//删  
linkedList.Remove(1); //删除指定元素  
linkedList.RemoveFirst(); //删除头部元素  
linkedList.RemoveLast(); //删除尾部元素  
linkedList.Remove(first); //删除指定节点  
linkedList.Clear(); //清空链表  
  
//查  
linkedList.Contains(1); //是否包含指定元素  
LinkedListNode<int> node1 = linkedList.Find(1); //查找指定元素  
LinkedListNode<int> node2 = linkedList.FindLast(1); //查找最后一个指定元素

//改  
//要先得到再改，得到节点，再改变其中的值  
LinkedListNode<int> node3 = linkedList.Find(1);  
node3.Value = 2;

//通过foreach遍历
foreach (var item in linkedList)
{
    Console.WriteLine(item);
}

//通过节点遍历 
//从头到尾
LinkedListNode<int> first = linkedList.First;
while (first != null)
{
    Console.WriteLine(node.Value);
    node = node.Next;
} 

//从尾到头
LinkedListNode<int> last = linkedList.Last;
while (last != null)
{
    Console.WriteLine(node4.Value);
    node4 = node4.Previous;
}

Stack<int> stack = new Stack<int>();

//压栈  
stack.Push("1");  
  
//出栈  
stack.Pop();

//查
//栈无法查看指定位置的元素,只能查看栈顶的内容  
s = stack.Peek(); //注意只是查看，不是出栈  
stack.Contains("1"); //查看元素是否存在于栈中  
stack.Count; //栈的长度

//改
stack.Clear(); //清空栈  

//栈不能使用[]访问，所以无法使用for循环遍历，一般使用foreach
foreach (var item in stack)
{
    Console.WriteLine(item);
}

//另一种方式
//将队列转换为object数组
object[] array = stack.ToArray();
for(int i =0;i<array.Length;i++)
{
    Console.WriteLine(array[i]);
}

//循环出栈
while (stack.Count>0)
{
    object p = stack.Pop();
}

Queue<int> queue = new Queue<int>();

//入队
queue.Enqueue("1");   、
//出队
queue.Dequeue();

//查

queue.Peek();  //查看队列头元素但不会移除  
queue.Contains("1"); //查看队列中是否包含某个元素  
queue.Count;//队列长度  

//改
queue.Clear();  //清空队列  

//队列不能使用[]访问，所以无法使用for循环遍历，一般使用foreach
foreach (var item in queue)
{
    Console.WriteLine(item);
}

//另一种方式
//将队列转换为object数组
object[] array = queue.ToArray();
for(int i =0;i<array.Length;i++)
{
    Console.WriteLine(array[i]);
}

//循环出队
while (queue.Count > 0)  
{  
    object v5 = queue.Dequeue();  
}

pubilc static 返回值类型 函数名（参数列表）
{
	函数体;
}
//public：访问修饰符
//static：静态的
//返回值类型：如果不需要写返回值，写void
//方法名：Pascal 每个单词首字母都大写
//参数列表：完成这个方法所必须要提供给这个方法的条件
    
 public static int GetMax(int n1, int n2)
{
    return n1> n2 ? n1 : n2;
}

static void ChangeValue (int a)
{
    a = 20;
}

int b = 10
ChangeValue(b); 
//因为值传递的原因，b的值没有改变，我们想让b被改成20可以使用ref：

//参数前添加 ref 修饰符 
static void ChangeValue (ref int a)
{
    a=20;
}
int b = 10
ChangeValue(b);
//b改变为20 在函数内修改传入参数 传入的参数在外部也会修改

public static void Test(int[]nums,out int max.out int min,out int sum,out float avr)
//out int max写到形参列表中
{
    max = nums[0];
    min = nums[1];
    sum = 0;
    avr = sum / nums.Length;
}

//外部调用：
Test（nums,out max,out min,out sun,out avr）;

// 未使用可变参数：
 static void Main(string[] args)
{
    int[] s = { 100, 80, 95 };
    Test("张三", s);   //主要区别再第二个参数这里
    Console.ReadKey();
}

public static void Test (string name, int[] score)
{
    int sum = 0;
    for(int i=0;i<score.Length;i++)
    {
        sum += score[i];
    }
    Console.WriteLine($"{name}这次考试总成绩是{sum}");
}

//改用params后：
 static void Main(string[] args)
{
   // int[] s = { 100, 80, 95 };
    Test("张三", 100, 80, 95); //可变长度，可以增加其他成绩
    Console.ReadKey();
}

public static void Test (string name, params int[] score)
{
    int sum = 0;
    for(int i=0;i<score.Length;i++)
    {
        sum += score[i];
    }
    Console.WriteLine($"{name}这次考试总成绩是{sum}");
}

static void Speak (string str == "hello")
{
    Console.WriteLine (str);
}

public static void M (int n1,int n2)
{
    int result = n1 + n2;
}

public static double M(double d1,double d2)
{
    return d1 + d2;
}

public static void M(int n1,int n2,int n3)
{
    int result = n1 + n2 + n3;
}

public static string M(string s1,string s2)
{
    return s1 + s2;
}

string a = @"C：\mycode\a\文件.txt";

public static 返回类型 operator 运算符(参数列表)

Point p1 = new Point();
p1.x =1;
p1.y =1;
Point p2 = new Point();
p2.x= 2;
p2.y = 2;
Point p3 =p1 + p2; //使用重载的+
Console.WriteLine(p3.x);

class Point
{
    public int x;
    public int y;

    public static Point operator +(Point p1, Point p2)
    {
        Point p = new Point();
        p.x = p1.x + p2.x;
        p.y = p1.y + p2.y;
        return p;
    }
}

try
{
    //可能出现异常的代码；
}
catch
{
    //出现异常后要执行的代码；
    //catch(Exception e)具体报错跟踪，通过e得到具体的错误信息
}
finally
{
    // （可选）最后执行的代码，不管有没有出错都会执行
}
//如果无异常，则catch内代码不会执行。如果出现异常，则后续代码不再执行，而是跳到catch的代码。（try-catch中间不能有其他代码）
// 注意三个语句后面不需要加;

private void Awake()
{
    throw new NotImplementedException();
}

foreach(数据类型 变量名 in 数组名)
{
  //语句块；
}

class Program
{
    static void Main(string[] args)
    {
        double[] points = { 80, 88, 86, 90, 75.5 };
        double sum = 0;
        double avg = 0;
        foreach(double point in points)
        {
            sum = sum + point;
        }
        avg = sum / points.Length;
        Console.WriteLine("总成绩为：" + sum);
        Console.WriteLine("平均成绩为：" + avg);
    }
}

member => expression;

public string Name
{
    get => "lk";
    set => Name = value;
}

public int Add(int a, int b) => a + b;

//注意和lambda表达式中的=>用法不同，后者可以用大括号包含完整逻辑
(参数列表)=>{ 函数逻辑 }

public string Name => locationName;
//相当于
public string Name { get=>locationName; }

语法：
public class 类名
{
	字段;
	属性;
	方法;
}

//规范:每写一个类要新建一个类文件

//类：
public class Person
{
    public string _name;
    public int _age;
    public string _gender;

    public void CHLSS()
    {
        Console.WriteLine($"我叫{this._name},我今年{this._age}岁了，我性别是{this._gender}。");
//this:表示当前这个类的对象。类是不占内存的，而对象是占内存的。
    }
}

//类调用：
static void Main(string[] args)
{
    //类的实例化，使用关键字 new.
    Person sunQuan = new Person();
    sunQuan._name = "孙权";
    sunQuan._age = 23;
    sunQuan._gender = "男";
    sunQuan.CHLSS();

    // 以下都是空对象，没有申请堆空间，不可以访问成员变量和成员函数
    Person p1;  
    Person p2 = null; //等价
}

class person
{
    Person girlfriend;
    Person girlfriend = new Person(); //error!
    
    Person[] boyfriend;
}

Person p = new Person();
Person.Body body = new Person.Body(); // 实例化时指出外部类

class Person
{
    //人
    public int age;
    public string name;
    public Body body;
    
    public class Body
    {
        //身体
        Arm leftArm;
        public class Arm
        {
            //手臂
        }
    }
}

//可以理解为将Person类分开，两部分共同组成Person类，数据共享
public partial class  Person
{ }
public partial class  Person
{ }

public sealed class Person : Test
{ }

public sealed overide void Eat()
{ }