C#（二）：数据类型、运算符、语句、类型转换、异常捕获、函数方法定义

太过爱你忘了你带给我的痛 2024-03-30 10:29 55阅读 0赞

#### 数据类型、运算符、语句、类型转换、异常捕获、函数方法定义 ####

*   *  命名约定
     *  变量
     *   *  文本
         *  数字
         *  布尔值
         *  任意类型 \`object\` \`dynamic\`
         *  声明局部变量
         *  获取类型的默认值
         *  数组
         *   *  数组定义方法
             *  \`x 行 y 列\` 的二维数组
             *  params 传参形式
             *  二分查找
             *  数组选择排序
             *  数组冒泡排序
     *  数据处理
     *   *  处理空值
         *  检查null
         *  格式化字符串
     *  运算符
     *   *  一元运算符
         *  二元运算符
         *  赋值运算符
         *  逻辑运算符
         *  条件逻辑运算符(短路布尔运算符)
         *  按位和二元位移运算符
     *  运算符的重载 operator
     *   *  特点
         *  哪些运算符可进行重载
     *  语句
     *  类型转换
     *   *  隐式类型转换
         *  显示类型转换
         *  强制类型转换 \`System.Convert\`
         *  圆整数字
         *  任意类型转换字符串
         *  二进制对象转换为字符串
         *  字符串转换为数值或日期和时间
     *  异常捕获
     *   *  检查溢出 \`checked\`
     *  方法定义
     *  递归
     *  重载
     *  \`ref\` 和 \`out\`

### 命名约定 ###

<table> 
 <thead> 
  <tr> 
   <th>命名约定</th> 
   <th>示例</th> 
   <th>适用场合</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>驼峰样式</td> 
   <td>cost、orderDetail、dateOfBirth</td> 
   <td>局部变量、私有变量</td> 
  </tr> 
  <tr> 
   <td>标题样式</td> 
   <td>String、Int32、Cost、DateOfBirth、Run</td> 
   <td>类型、非私有字段以及其他成员(如方法)</td> 
  </tr> 
 </tbody> 
</table>

### 变量 ###

![在这里插入图片描述][cf7c6598dc8a49218c21649dd88675d4.png_pic_center]

#### 文本 ####

***字符***

char a = 'A';
    char b = 'L';

***内插字符串***

string name = "Lee";
    Console.WriteLine($"Hello, {
          name}!"); // Hello, Lee!

***字面字符串***

string filePath1 = "C:\txxx\\xxx\\xxx.txt";
    Console.WriteLine(filePath1); // C:      xxx\xxx\xxx.txt

***逐字字符串***

string filePath2 = @"C:\txxx\nxxx\rxxx.txt";
    Console.WriteLine(filePath2); // C:\txxx\nxxx\rxxx.txt

#### 数字 ####

***整型***

uint a = 1; // 无符号整型
    int b = -2; // 整数类型
    Console.WriteLine(a + b == -1.0); // True

***浮点型***

float c = 1;
    float d = 0.1F;
    float e = 0.2f;
    Console.WriteLine(d + e == 0.3); // False

***双精度浮点型***

double f = 0.1;
    double g = 0.2f;
    Console.WriteLine(f + g == 0.3); // False

// 不是数字
    Console.WriteLine(double.NaN); // NaN
    Console.WriteLine(double.IsNaN(double.NaN)); // True
    
    // 最小正数
    Console.WriteLine(double.Epsilon); // 4.94065645841247E-324
    
    // 判断值是否无限大
    Console.WriteLine(double.IsInfinity(1)); // True

***精准数据类型***

decimal h = 0.1M;
    decimal i = 0.2m;
    Console.WriteLine(h + i == 0.3M); // True

#### 布尔值 ####

bool a = true;
    bool b = false;

#### 任意类型 `object` `dynamic` ####

***object***

object name = "Lee";
    Console.WriteLine(((string)name).Length); // 3
    
    object num1 = "123";
    object num2 = 123;
    Console.WriteLine((int)num1 + (int)num2); // 未经处理的异常:  System.InvalidCastException: 指定的转换无效。

***dynamic***

dynamic name = "ProsperLee";
    Console.WriteLine(name.Length); // 10

#### 声明局部变量 ####

var name = "ProsperLee";
    Console.WriteLine(name.Length); // 10

#### 获取类型的默认值 ####

Console.WriteLine(default(DateTime)); // 0001/1/1 0:00:00
    
    Console.WriteLine(default(char) == '\0'); // True
    Console.WriteLine(default(string) == null); // True
    
    Console.WriteLine(default(uint) == 0); // True
    Console.WriteLine(default(int) == 0); // True
    Console.WriteLine(default(float) == 0); // True
    Console.WriteLine(default(double) == 0); // True
    Console.WriteLine(default(decimal) == 0); // True
    
    Console.WriteLine(default(bool));   // False
    
    Console.WriteLine(default(object) == null); // True

#### 数组 ####

string[] names = {
         "Lee", "Tom", "Lucy" };
    foreach (string name in names) 
    {
        
        Console.WriteLine(name); // Lee Tom Lucy
    }
    
    object[] list1 = {
         "Lee", 123, true, 1.23m };
    dynamic[] list2 = {
         "Lee", 123, true, 1.23m };
    foreach (object d in list1)
    {
        
        Console.WriteLine(d); // Lee 123 True 1.23
    }
    foreach (var d in list2)
    {
        
        Console.WriteLine(d); // Lee 123 True 1.23
    }

##### 数组定义方法 #####

int[] arr0 = new int[10];
    
    int[] arr1 = new int[3] {
         1, 2, 3 };
    
    int[] arr2 = new int[] {
         1, 2, 3, 4, 5, 6 };
    
    int[] arr3 = {
         1, 2, 3, 4, 5, 6 };

##### `x 行 y 列` 的二维数组 #####

int[,] arr = new int[3, 4];
    
    arr[0, 1] = 12;
    
    foreach (int item in arr)
    {
        
        Console.WriteLine(item);
    }

##### params 传参形式 #####

class MainClass
    {
        
        public static void Main(string[] args)
        {
        
    
            int[] arr = {
         1, 2, 3, 4, 5, 6 };
    
            ForArray(arr); // 1 2 3 4 5 6
    
            ForArray(new int[5]); // 0 0 0 0 0 
    
            ForArray(new int[] {
         1, 2, 3, 4, 5, 6 }); // 1 2 3 4 5 6
    
            ForArray(1, 2, 3, 4, 5, 6); // 1 2 3 4 5 6
    
    
        }
    
        //public static void ForArray(int[] array)
        //{
        
        //    foreach (int item in array)
        //    {
        
        //        Console.WriteLine(item);
        //    }
        //}
    
        public static void ForArray(params int[] array)
        {
        
            foreach (int item in array)
            {
        
                Console.WriteLine(item);
            }
        }
    
    }

##### 二分查找 #####

*  利用二分查找查询升序数组中指定元素的下标
    
        class MainClass
        {
              
        
            public static void Main(string[] args)
            {
              
        
                int[] array = {
               1, 2, 4, 5, 6, 8 };
                Console.WriteLine(FindIndex(array, 6)); 
        
            }
        
            /// <summary>
            /// 利用二分查找查询升序数组中指定元素的下标
            /// </summary>
            /// <param name="array">目标数组</param>
            /// <param name="num">要查找的数</param>
            /// <returns>元素下标</returns>
            public static int FindIndex(int[] array, int num) {
              
        
                int index = -1;
        
                int min = 0;
        
                int max = array.Length - 1;
        
                while (max >= min) {
              
        
                    int mid = (min + max) / 2;
        
                    if (array[mid] == num)
                    {
              
                        index = mid;
                        break;
                    }
                    else if (array[mid] > num)
                    {
              
                        max = mid - 1; 
                    }
                    else {
              
                        min = mid + 1;
                    }
        
                }
        
                return index;
        
            }
        
        }

##### 数组选择排序 #####

public static int[] SortArray(int[] array) 
    {
        
    
        for (int i = 0; i < array.Length - 1; i++) {
        
    
            for(int j = i + 1; j < array.Length; j++) {
        
    
                if (array[i] > array[j])
                {
        
                    int num = array[i];
                    array[i] = array[j];
                    array[j] = num;
                }
    
            }
    
        }
    
        return array;
    
    }
    
    foreach (int item in SortArray(new int[] {
         1, 3, 5, 1, 5, -1, 24, 12 })) {
        
        Console.WriteLine(item); // -1 1 1 3 5 5 12 24
    }

##### 数组冒泡排序 #####

public static int[] SortArray(int[] array)
    {
        
        for(int i = 0; i < array.Length - 1; i++)
        {
        
            for (int j = 0; i + j < array.Length - 1; j++)
            {
        
                if (array[j] > array[j + 1]) {
        
                    int num = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = num;
                }
            }
        }
    
        return array;
    
    }
    
    foreach (int item in SortArray(new int[] {
         1, 3, 5, 1, 5, -1, 24, 12 })) {
        
        Console.WriteLine(item); // -1 1 1 3 5 5 12 24
    }

### 数据处理 ###

#### 处理空值 ####

int num = new Random().Next(0, 10);
    int? a;
    if (num > 5) a = num; else a = null;
    Console.WriteLine(a); // [0, 10) or null

#### 检查null ####

int num = new Random().Next(0, 10);
    string str;
    if (num > 5) str = "ProsperLee"; else str = null;
    Console.WriteLine(str?.Length); // 10 or null
    Console.WriteLine(str?.Length ?? 123); // 10 or 123

#### 格式化字符串 ####

> 格式：`{ index [, alignment ] [ :formatString ] }`

// 苹果：10个；总价：￥20.00；
    Console.WriteLine(
        format: "苹果：{0}个；总价：{1:C}；",
        arg0: 10,
        arg1: 2 * 10
    );
    
    // 苹果：10个；总价：￥20.00；
    string str = string.Format(
        format: "苹果：{0}个；总价：{1:C}；",
        arg0: 10,
        arg1: 2 * 10
    );
    Console.WriteLine(str);
    
    // 苹果：10个；总价：￥20.00；
    int num = 10;
    int price = 2;
    Console.WriteLine($"苹果：{
          num}个；总价：{
          num * price:C}；");

### 运算符 ###

#### 一元运算符 ####

> `++` `--`

#### 二元运算符 ####

> `+` `-` `*` `/` `%`

***除法 `/`***

*  整型之间的除法结果为商数
    
        Console.WriteLine(10 / 3); // 3
 *  含有浮点数参与的除法结果为浮点数
    
        Console.WriteLine(10 / 3f); // 3.333333
        Console.WriteLine(10.00 / 3); // 3.33333333333333
        Console.WriteLine(10.5 / 3); // 3.5

#### 赋值运算符 ####

> `+=` `-=` `*=` `/=`

#### 逻辑运算符 ####

> `&` `|` `^`

***`异或 ^` 和 `位异或 ^`***

*  `true` 和 `false` 参与判断时
    
     *  如果两个结果相同，返回值为 `false`
        
            Console.WriteLine(true ^ true); // False
            Console.WriteLine(false ^ false); // False
     *  如果两个结果不同，返回值为 `true`
        
            Console.WriteLine(false ^ true); // True
            Console.WriteLine(true ^ false); // True

#### 条件逻辑运算符(短路布尔运算符) ####

> `&&` `||`

> `!`

#### 按位和二元位移运算符 ####

> `&` `|` `^`

***`表达式` `数字` 参与判断***

Console.WriteLine(-10 ^ 10); // -4
    // 1000 1010  原  -10
    // 1111 0101  反  -10
    // 1111 0110  补  -10
    // 0000 1010  补  +10
    // ------------------
    // 1111 1100  补  计算结果 => 按位异或 1^0 1^0 1^0 1^0   0^1 1^0 1^1 0^0
    // 1000 0011  反  求反
    // 1000 0100  原  求原
    // -(2^2) = -4

Console.WriteLine(10 ^ 10); // 0
    // 0000 1010 原反补  +10
    // 0000 1010 原反补  +10
    // --------------------
    // 0000 0000 原反补  计算结果 0

Console.WriteLine(6 ^ 10); // 12
    // 0000 0110 原反补  +6
    // 0000 1010 原反补  +10
    // --------------------
    // 0000 1100 原反补  计算结果 8 + 4 = 12

***位或 `|`***

Console.WriteLine(-10 | 10); // -2
    // 1000 1010  原  -10
    // 1111 0101  反  -10
    // 1111 0110  补  -10
    // 0000 1010  原反补 +10
    // 1111 1110  补  计算结果 
    // 1000 0001  反  求反
    // 1000 0010  原  求原 -2

Console.WriteLine(10 | 2); // 10
    // 0000 1010  原反补
    // 0000 0010  原反补
    // 0000 1010  原反补 10
    
    Console.WriteLine(10 | 12); // 14
    // 0000 1010  原反补
    // 0000 1100  原反补
    // 0000 1110  原反补 14

***位与 `&`***

Console.WriteLine(-10 & 10); // 2
    // 1000 1010  原
    // 1111 0101  反
    // 1111 0110  补
    // 0000 1010  原反补
    // 0000 0010  原反补 2
    
    Console.WriteLine(10 & 2); // 2
    // 0000 1010  原反补
    // 0000 0010  原反补
    // 0000 0010  原反补 2
    
    Console.WriteLine(10 & 12); // 8
    // 0000 1010  原反补
    // 0000 1100  原反补
    // 0000 1000  原反补 8

***位反 `~`***

Console.WriteLine(~10);
    // 0000 1010  原反补  +10
    // 1111 0101  补 ~10
    // 1000 1010  反
    // 1000 1011  原
    // -11
    
    
    Console.WriteLine(~-10);
    // 1000 1010  原  -10
    // 1111 0101  反  -10
    // 1111 0110  补  -10
    // 0000 1001  原反补  ~-10
    // 9
    
    
    Console.WriteLine(~-8);
    // 1000 1000  原  -8
    // 1111 0111  反  -8
    // 1111 1000  补  -8
    // 0000 0111  原反补  ~-8
    // 8

> `<<` `>>`

***`位左移 <<` 和 `位右移 >>`***

Console.WriteLine(10 << 2); // 40  =>  10 * 2^2 = 40
    // ---- 0000 1010 ----
    // ---- 0000 1010 00--
    // ---- --00 1010 00--
    // 0010 1000
    // 2^5 + 2^3 = 40
    
    Console.WriteLine(10 >> 2); // 2  =>  10 / 2^2 = 2
    // ---- 0000 1010 ----
    // --00 0000 1010 ----
    // --00 0000 10-- ----
    // 0000 0010
    // 2^1 = 2
    
    Console.WriteLine(-8 << 2); // -32  =>  -(8 * 2^2) = -32
    // =>  -(8 << 2)
    // ---- 0000 1000 ----
    // ---- 0000 1000 00--
    // ---- --00 1000 00--
    // 0010 0000
    // 32
    
    Console.WriteLine(-8 >> 2); // -2  =>  -(8 / 2^2) = -2
    // =>  -(8 >> 2)
    // ---- 0000 1000 ----
    // --00 0000 1000 ----
    // --00 0000 10-- ----
    // 0000 0010
    // 2

### 运算符的重载 operator ###

struct Point {
        
        public double x;
        public double y;
    
        public Point(double x, double y) {
        
            this.x = x;
            this.y = y;
        }
    
        // 加号方法
        public static Point operator +(Point p1, Point p2)
        {
        
            return new Point(p1.x + p2.x, p1.y + p2.y);
        }
    
        // 参数类型
        public static Point operator +(Point p1, int a)
        {
        
            return new Point(p1.x + a, p1.y + a);
        }
    
        // 返回类型
        public static int[] operator +(int a, Point p1)
        {
        
            return new int[]{
         (int)(p1.x + a), (int)(p1.y + a) };
        }
    
        // 修改 & （正确但不合乎常理）
        public static int[] operator &(int a, Point p1)
        {
        
            return new int[] {
         (int)(p1.x + a), (int)(p1.y + a) };
        }
    
        // 减号方法
        public static Point operator -(Point p1)
        {
        
            return new Point(-p1.x, -p1.y);
        }
    }
    
    class MainClass
    {
        
        public static void Main(string[] args)
        {
        
            Point a = new Point(1, 2);
            Console.WriteLine(a.x); // 1
            Console.WriteLine(a.y); // 2
    
            Point b = new Point(3, 4);
            Console.WriteLine(b.x); // 3
            Console.WriteLine(b.y); // 4
    
            Point c = a + b;
            Console.WriteLine(c.x); // 4
            Console.WriteLine(c.y); // 6
    
            Point d = new Point(1, 2);
            Point e = -d;
            Console.WriteLine(e.x); // -1
            Console.WriteLine(e.y); // -2
    
            Point f = new Point(1, 2);
            int g = 10;
            Point h = f + g;
            Console.WriteLine(h.x); // 11
            Console.WriteLine(h.y); // 12
    
            int i = 1;
            Point j = new Point(1, 2);
            int[] k = i + j;
            foreach (int item in k)
            {
        
                Console.WriteLine(item); // 2 3
            }
    
            int l = 1;
            Point m = new Point(1, 2);
            int[] n = l + m;
            foreach (int item in n)
            {
        
                Console.WriteLine(item); // 2 3
            }
        }
    }

#### 特点 ####

*  运算符重载方法的参数必须与运算符可操作的数据一致
    
     *  一元运算符：操作一个数据 `!` `-` ···
     *  二元运算符：操作两个数据 `*` `/` ···
     *  三元运算符：操作三个数据 `? :` ···

#### 哪些运算符可进行重载 ####

*  全部可以进行重载：
    
     *  算数运算符
     *  关系运算符(重载必须成对)
        
         *  `比如重载了 > ,就必须重载 <`
 *  全部不可进行重载：
    
     *  赋值运算符
 *  部分可以进行重载：
    
     *  逻辑运算符
        
         *  可进行：`&` `|` `!` `^`
         *  不可进行: `&&` `||`
     *  位运算符
        
         *  可进行：`~`

### 语句 ###

> `if... else if ... else ...`

> `switch`

int num = new Random().Next(0, 3);
    switch (num)
    {
        
        case 1:
            Console.WriteLine(1);
            break;
        case 2:
            Console.WriteLine(2);
            break;
        default:
            Console.WriteLine("default: 0");
            break;
    }

> `while`

int count = 0;
    while (count < 6)
    {
        
        Console.WriteLine(count); // 0 1 2 3 4 5
        count++;
    }

> `do { ... } while (...)`

int i = 1;
    do
    {
        
        Console.Write("{0} ", i);
        i++;
    } while (i <= 6);

> `for (int i = 0; i <= 6; i++) { ... }`

> `foreach`

string[] names = {
         "Lee", "Tom", "Lucy" };
    foreach (string name in names)
    {
        
        Console.WriteLine(name); // Lee Tom Lucy
    }

### 类型转换 ###

#### 隐式类型转换 ####

int a = 10;
    double b = a;
    Console.WriteLine(b); // 10

#### 显示类型转换 ####

double a = 1.53;
    int b = (int)a;
    Console.WriteLine(b); // 1

#### 强制类型转换 `System.Convert` ####

int a = System.Convert.ToInt32("123");
    Console.WriteLine(a); // 123
    
    double b = System.Convert.ToDouble("123.456");
    Console.WriteLine(b); // 123.456

#### 圆整数字 ####

***规则***

*  `如果小数部分小于0.5，则向下圆整；`
 *  `如果小数部分大于0.5，则向上圆整；`
 *  `如果小数部分等于0.5，那么非小数部分为奇数时，则向上圆整，非小数部分为偶数时，则向下圆整；`

double[] nums = {
         1, 1.4, 1.49, 1.5, 2.5, 1.59, 1.99 };
    foreach (double num in nums)
    {
        
        int n = System.Convert.ToInt32(num);
        Console.WriteLine(n); // 1 1 1 2 2 2 2
    }

***控制圆整规则***

> `Math.Round(...)`

#### 任意类型转换字符串 ####

Console.WriteLine(string.Empty.ToString() == ""); // True

#### 二进制对象转换为字符串 ####

> 用途：
> 
> `对于将要存储或传输的二进制对象，例如图像或视频，有时不想发送原始位，因为不知道如何解释那些位，例如通过网络协议传输或由另一个操作系统读取及存储的二进制对象。`
> 
> `最安全的做法是将二进制对象转换成安全字符串，也就是Base64编码。`

![在这里插入图片描述][0a03deb1c4ef497eb94e7e4674a7a1e5.png_pic_center]

byte[] bytes = new byte[128];
    new Random().NextBytes(bytes);
    
    Console.WriteLine("Bytes:");
    for (int i = 0; i < bytes.Length; i++)
    {
        
        Console.Write($"{
          bytes[i]:X} ");
    }
    
    Console.WriteLine("Base64:");
    Console.WriteLine(Convert.ToBase64String(bytes));

#### 字符串转换为数值或日期和时间 ####

int age = int.Parse("25");
    DateTime birthday = DateTime.Parse("1997-02-11");
    
    Console.WriteLine(age); // 25
    Console.WriteLine(birthday); // 1997/2/11 0:00:00

***TryParse：避免异常***

int num1;
    Console.WriteLine(int.TryParse("abc", out num1)); // False
    Console.WriteLine(num1); // 0
    
    Console.WriteLine(int.TryParse("12.34", out int num2)); // False
    Console.WriteLine(num2); // 0
    
    Console.WriteLine(int.TryParse("123", out int num3)); // True
    Console.WriteLine(num3); // 123

### 异常捕获 ###

try
    {
        
        int.Parse("abc");
    }
    catch (Exception err)
    {
        
        Console.WriteLine($"{
          err.GetType()} ---> {
          err.Message}"); // System.FormatException ---> 输入字符串的格式不正确。
    }

#### 检查溢出 `checked` ####

int count = int.MaxValue - 1;
    Console.WriteLine(count); // 2147483646 继续累加
    count++;
    Console.WriteLine(count); // 2147483647 此时为最大值
    count++;
    Console.WriteLine(count); // -2147483648 此时溢出到了最小值上
    count++;
    Console.WriteLine(count); // -2147483647 继续累加

try
    {
        
        checked
        {
        
            int count = int.MaxValue - 1;
            Console.WriteLine(count); // 2147483646 继续累加
            count++;
            Console.WriteLine(count); // 2147483647 此时为最大值
            count++;
            Console.WriteLine(count);
            count++;
            Console.WriteLine(count);
        }
    }
    catch (Exception err)
    {
        
        Console.WriteLine($"{
          err.GetType()} ---> {
          err.Message}"); // System.OverflowException--->算术运算导致溢出。
    }

***自定义异常***

class Program
    {
        
        static void Main(string[] args)
        {
        
            try {
        
                ScoreExceptionDemo();
            }
            catch (Exception e)
            {
        
                Console.WriteLine(e); // 自定义异常描述
            }
        }
    
        static void ScoreExceptionDemo() {
        
            ScoreException scoreException = new ScoreException("自定义异常描述");
            throw scoreException;
        }
    }
    
    // 自定义异常
    class ScoreException : Exception {
        
        public ScoreException(string message) : base(message) {
        
            Console.WriteLine(message);
        }
    }

### 方法定义 ###

> `[访问权限修饰符] [其他的修饰符] 返回值类型 方法名 ([行参列表]) { /* 方法体 */ }`

public static string FunA(string str)
    {
        
    
        Console.WriteLine(str);
    
        return str;
    
    }

### 递归 ###

*  n的阶乘

class MainClass
    {
        
        public static void Main(string[] args)
        {
        
    
            Console.WriteLine(FunA(3));
    
        }
    
        public static int FunA(int n)
        {
        
    
            return n == 0 ? 1 : n * FunA(n - 1);
    
        }
    
    }

### 重载 ###

> 在一个类中，如果由多个方法满足以下几个条件，那么这几个方法是重载关系
> 
> 1.  方法名相同
> 2.  参数不同 (数量不同，类型不同)
> 3.  跟返回值无关系

class MainClass
    {
        
        public static void Main(string[] args)
        {
        
    
            Add(1);
    
            Add(1, 1f);
    
        }
    
        static void Add(int a, float b) 
        {
        
            Console.WriteLine(a + b);
        }
        
        static int Add(int a)
        {
        
            return a;
        }
    
    }

### `ref` 和 `out` ###

*  `ref`
    
     *  用来修饰参数
     *  如果一个形参用`ref`修饰，那么实参也需要用`ref`修饰
     *  `a`的改变是因为用`ref`修饰的参数最终传的是实参的`地址`
    
        public static void Change(ref int x) {
              
            x = 20;
        }
        
        int a = 10;
        Change(ref a);
        Console.WriteLine(a); // 20
 *  `out`
    
     *  用来修饰参数
     *  如果一个形参用`out`修饰，那么实参也需要用`out`修饰
     *  `a`的改变是因为用`out`修饰的参数最终传的是实参的`地址`
    
        public static void Change(out int x)
        {
              
            x = 20;
        }
        
        Change(out int a);
        Console.WriteLine(a);
 *  区别
    
     *  在方法结束之前必须对`out`参数赋值
        
            public static void Change(out int x) {
                     } // Error 没有对参数x进行赋值
     *  `ref`参数可以直接使用，而`out`参数需要进行赋值后才能使用（`ref参数默认被赋值了而out参数默认没有被赋值`）
        
            public static void Change(ref int x)
            {
                    
                Console.WriteLine(x); // ok
            }
            
            public static void Change(out int x)
            {
                    
                Console.WriteLine(x); // Error 使用了未赋值的变量x
                x = 20;
                Console.WriteLine(x); // ok
            }

[cf7c6598dc8a49218c21649dd88675d4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d7ea9699a07d4e689bb90d07686fba1c.png
[0a03deb1c4ef497eb94e7e4674a7a1e5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2f00b26cf75c4129ba963ffd1270a58b.png