【C#】.Net基础语法二

秒速五厘米 2024-03-02 10:33 26阅读 0赞

**目录**

一、字符串(String)

【1.1】字符串创建和使用

【1.2】字符串其他方法

【1.3】字符串格式化的扩展方法

【1.4】字符串空值和空对象比较

【1.5】字符串中的转移字符

【1.6】大写的String和小写的string

【1.7】StringBuilder类的重要性

二、数组(Array)

【2.1】声明数组

【2.2】赋值数组

【2.3】使用数组

【2.4】区分值类型变量和引用类型变量

三、动态数组

【3.1】动态数组简单应用

【3.2】动态数组常用属性和方法

四、常量

五、枚举(Enum)

【5.1】枚举类型声明

【5.2】常见的系统枚举

【5.3】枚举类型的转化

--------------------

## 一、字符串(String) ##

### 【1.1】字符串创建和使用 ###

您可以使用以下方法之一来创建 string 对象：

*  通过给 String 变量指定一个字符串
 *  通过使用 String 类构造函数
 *  通过使用字符串串联运算符（ + ）
 *  通过检索属性或调用一个返回字符串的方法
 *  通过格式化方法来转换一个值或对象为它的字符串表示形式

static void TestCode()
    {
        string email = "xxxxxx@qq.com";
        // 获取指定字符串第一个字符的索引
        int index1 = email.IndexOf("@");      // 返回索引
        int index2 = email.IndexOf("qq.com"); // 返回起始索引
        int index3 = email.IndexOf("qq.net"); // 如果没有找到返回-1
        Console.WriteLine($"{index1} {index2} {index3}"); // 打印结果：6 7 -1
    
        // 获取字符串的长度
        int lenght = email.Length;
        Console.WriteLine($"字符串长度：{lenght}"); // 打印结果：13
    
        // 字符串截取Substring方法
        string str1 = email.Substring(0, 6);
        Console.WriteLine($"截取内容：{str1}"); // 打印结果：xxxxxx
        string str2 = email.Substring(0, email.IndexOf("@"));
        Console.WriteLine($"截取内容：{str2}"); // 打印结果：xxxxxx
        string str3 = email.Substring(email.IndexOf("@") + 1);
        Console.WriteLine($"截取内容：{str3}"); // 打印结果：qq.com
    
        // 字符串比较
        string strName1 = "jack";
        string strName2 = "jack";
        string strName3 = "jddd";
        Console.WriteLine(strName1 == strName2); // 打印结果：True
        Console.WriteLine(strName1 == strName3); // 打印结果：False
        Console.WriteLine("strName1 == strName2：" + (strName1 == strName2)); // 打印结果：strName1 == strName2：True
        Console.WriteLine("strName1 == strName3：" + (strName1 == strName3)); // 打印结果：strName1 == strName3：True
        // Equals是一个虚方法
        Console.WriteLine(strName1.Equals(strName2)); // 打印结果：True   
        Console.WriteLine(strName1.Equals(strName3)); // 打印结果：False
        // 提示：==或Equals方法默认智能比较“值类型”或者“字符串”类型，对象类型(引用类型)是不能使用这种比较方法的。
            
        string str4 = "askjdhASDAasd";
        // 字符串转换为小写
        Console.WriteLine(str4.ToLower()); // 打印结果：askjdhasdaasd
        // 字符串转换为大写
        Console.WriteLine(str4.ToUpper()); // 打印结果：ASKJDHASDAASD
        
        // 字符串去掉前后空格
        Console.WriteLine(str4.Trim());    // 打印结果：askjdhASDAasd
        
        // 字符串分割和拼接
        // Split():基于数组中的字符将字符串拆分为多个子字符串。
        // string.Join():串联字符串数组的所有元素，其中在每个元素之间使用指定的分隔符。
        string strVal = "AB CD EF HU 00";
        Console.WriteLine(strVal);
    
        // 将字符串进行分割
        string[] strArray = strVal.Split(' ');
        foreach(string val in strArray)
        {
            Console.WriteLine(val + " ");
        }
    
        // 将字符串数组重新拼接
        string strJoin = string.Join("_", strArray);
        Console.WriteLine(strJoin);
    
    
        // 字符串替换
        // Replace(): 返回一个新字符串，其中此实例中出现的所有指定 Unicode 字符都替换为另一个指定的 Unicode 字符。
        string strVal2 = "AB CD EF HU 00";
        Console.WriteLine(strVal2);
        string strVal3 = strVal2.Replace(' ', '@');
        Console.WriteLine(strVal3);
    
        Console.Read();
    }

### 【1.2】字符串其他方法 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法名称 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><strong>public static int Compare( string strA, string strB )</strong> 比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。该方法区分大小写。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><strong>public static int Compare( string strA, string strB, bool ignoreCase )</strong> 比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。但是，如果布尔参数为真时，该方法不区分大小写。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><strong>public static string Concat( string str0, string str1 )</strong> 连接两个 string 对象。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><strong>public static string Concat( string str0, string str1, string str2 )</strong> 连接三个 string 对象。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><strong>public static string Concat( string str0, string str1, string str2, string str3 )</strong> 连接四个 string 对象。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><strong>public bool Contains( string value )</strong> 返回一个表示指定 string 对象是否出现在字符串中的值。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><strong>public static string Copy( string str )</strong> 创建一个与指定字符串具有相同值的新的 String 对象。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><strong>public void CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count )</strong> 从 string 对象的指定位置开始复制指定数量的字符到 Unicode 字符数组中的指定位置。</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><strong>public bool EndsWith( string value )</strong> 判断 string 对象的结尾是否匹配指定的字符串。</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><strong>public bool Equals( string value )</strong> 判断当前的 string 对象是否与指定的 string 对象具有相同的值。</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><strong>public static bool Equals( string a, string b )</strong> 判断两个指定的 string 对象是否具有相同的值。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><strong>public static string Format( string format, Object arg0 )</strong> 把指定字符串中一个或多个格式项替换为指定对象的字符串表示形式。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><strong>public int IndexOf( char value )</strong> 返回指定 Unicode 字符在当前字符串中第一次出现的索引，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td><strong>public int IndexOf( string value )</strong> 返回指定字符串在该实例中第一次出现的索引，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td><strong>public int IndexOf( char value, int startIndex )</strong> 返回指定 Unicode 字符从该字符串中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td><strong>public int IndexOf( string value, int startIndex )</strong> 返回指定字符串从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td><strong>public int IndexOfAny( char[] anyOf )</strong> 返回某一个指定的 Unicode 字符数组中任意字符在该实例中第一次出现的索引，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td><strong>public int IndexOfAny( char[] anyOf, int startIndex )</strong> 返回某一个指定的 Unicode 字符数组中任意字符从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td><strong>public string Insert( int startIndex, string value )</strong> 返回一个新的字符串，其中，指定的字符串被插入在当前 string 对象的指定索引位置。</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td><strong>public static bool IsNullOrEmpty( string value )</strong> 指示指定的字符串是否为 null 或者是否为一个空的字符串。</td> 
  </tr> 
  <tr> 
   <td>21</td> 
   <td><strong>public static string Join( string separator, string[] value )</strong> 连接一个字符串数组中的所有元素，使用指定的分隔符分隔每个元素。</td> 
  </tr> 
  <tr> 
   <td>22</td> 
   <td><strong>public static string Join( string separator, string[] value, int startIndex, int count )</strong> 连接一个字符串数组中的指定位置开始的指定元素，使用指定的分隔符分隔每个元素。</td> 
  </tr> 
  <tr> 
   <td>23</td> 
   <td><strong>public int LastIndexOf( char value )</strong> 返回指定 Unicode 字符在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>24</td> 
   <td><strong>public int LastIndexOf( string value )</strong> 返回指定字符串在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。</td> 
  </tr> 
  <tr> 
   <td>25</td> 
   <td><strong>public string Remove( int startIndex )</strong> 移除当前实例中的所有字符，从指定位置开始，一直到最后一个位置为止，并返回字符串。</td> 
  </tr> 
  <tr> 
   <td>26</td> 
   <td><strong>public string Remove( int startIndex, int count )</strong> 从当前字符串的指定位置开始移除指定数量的字符，并返回字符串。</td> 
  </tr> 
  <tr> 
   <td>27</td> 
   <td><strong>public string Replace( char oldChar, char newChar )</strong> 把当前 string 对象中，所有指定的 Unicode 字符替换为另一个指定的 Unicode 字符，并返回新的字符串。</td> 
  </tr> 
  <tr> 
   <td>28</td> 
   <td><strong>public string Replace( string oldValue, string newValue )</strong> 把当前 string 对象中，所有指定的字符串替换为另一个指定的字符串，并返回新的字符串。</td> 
  </tr> 
  <tr> 
   <td>29</td> 
   <td><strong>public string[] Split( params char[] separator )</strong> 返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。</td> 
  </tr> 
  <tr> 
   <td>30</td> 
   <td><strong>public string[] Split( char[] separator, int count )</strong> 返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。int 参数指定要返回的子字符串的最大数目。</td> 
  </tr> 
  <tr> 
   <td>31</td> 
   <td><strong>public bool StartsWith( string value )</strong> 判断字符串实例的开头是否匹配指定的字符串。</td> 
  </tr> 
  <tr> 
   <td>32</td> 
   <td><strong>public char[] ToCharArray()</strong> 返回一个带有当前 string 对象中所有字符的 Unicode 字符数组。</td> 
  </tr> 
  <tr> 
   <td>33</td> 
   <td><strong>public char[] ToCharArray( int startIndex, int length )</strong> 返回一个带有当前 string 对象中所有字符的 Unicode 字符数组，从指定的索引开始，直到指定的长度为止。</td> 
  </tr> 
  <tr> 
   <td>34</td> 
   <td><strong>public string ToLower()</strong> 把字符串转换为小写并返回。</td> 
  </tr> 
  <tr> 
   <td>35</td> 
   <td><strong>public string ToUpper()</strong> 把字符串转换为大写并返回。</td> 
  </tr> 
  <tr> 
   <td>36</td> 
   <td><strong>public string Trim()</strong> 移除当前 String 对象中的所有前导空白字符和后置空白字符。</td> 
  </tr> 
 </tbody> 
</table>

### 【1.3】字符串格式化的扩展方法 ###

<table> 
 <thead> 
  <tr> 
   <th>字符</th> 
   <th>说明</th> 
   <th>实例</th> 
   <th>输出结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>C</td> 
   <td>货币格式</td> 
   <td>string.Format(" {0:C3}", 5000)</td> 
   <td>￥5000.000</td> 
  </tr> 
  <tr> 
   <td>D</td> 
   <td>十进制格式</td> 
   <td>string.Format(" {0:D3}", 5000)</td> 
   <td>5000</td> 
  </tr> 
  <tr> 
   <td>F</td> 
   <td>小数点后的位数固定</td> 
   <td>string.Format(" {0:F3}", 5000)</td> 
   <td>5000.00</td> 
  </tr> 
  <tr> 
   <td>N</td> 
   <td>用逗号隔开的数字</td> 
   <td>string.Format(" {0:N}", 250000)</td> 
   <td>250,000.0</td> 
  </tr> 
  <tr> 
   <td>P</td> 
   <td>百分比计数法</td> 
   <td>string.Format(" {0:P3}", 0.25755)</td> 
   <td>257.55%</td> 
  </tr> 
  <tr> 
   <td>X</td> 
   <td>十六进制格式</td> 
   <td>string.Format(" {0:X000}", 12)</td> 
   <td>C</td> 
  </tr> 
 </tbody> 
</table>

static void TestCode()
    {
        Console.WriteLine(string.Format(" {0:C3}", 5000));      // 打印结果： ￥5,000.000
        Console.WriteLine(string.Format(" {0:D3}", 5000));      // 打印结果： 5000
        Console.WriteLine(string.Format(" {0:F3}", 5000));      // 打印结果： 5000.000
        Console.WriteLine(string.Format(" {0:N}", 250000));     // 打印结果： 250,000.00
        Console.WriteLine(string.Format(" {0:P2}", 25000));     // 打印结果： 2,500,000.00%
        Console.WriteLine(string.Format(" {0:P3}", 25000));     // 打印结果： 2,500,000.000%
        Console.WriteLine(string.Format(" {0:P3}", 0.25755));   // 打印结果： 25.755%
        Console.WriteLine(string.Format(" {0:X000}", 12));      // 打印结果： C
    
        double sum = 2.1231241;
        Console.WriteLine(sum.ToString("0.00"));  // 打印结果：2.12
        Console.WriteLine(sum.ToString("0.000")); // 打印结果：2.123
    
        Console.Read();
    }

### 【1.4】字符串空值和空对象比较 ###

static void TestCode()
    {
        // 这个“空”字符串是占用空间的
        string str1 = "";
    
        // 和 string str1 = "" 一样
        string str2 = string.Empty;
    
        // 这个会有语法错误
        // string str3;
    
        // 这个是存在一个赋值过程的，不占用空间
        string str4 = null; // 如果这样直接使用会出现错误，为引用的对象
    
        // 判断字符串为空值
        if (str1.Length == 0) ;
        if (str1 == string.Empty) ;
        if (str1 == "") ;
        // 判断字符串为空
        if (str1 == null) ;
    
        // 推荐使用方法
        // 如果 true 参数为 value 或 null，或者如果 Empty 仅由空白字符组成，则为 value。
        string.IsNullOrWhiteSpace(str1); 
    }

### 【1.5】字符串中的转移字符 ###

*  转移字符：具有特定含义，不用于字符原有的意思。
 *  常用反斜杠：【\\\\】【@】

static void TestCode()
    {
        string path1 = "C:\\DB\\Test.txt";
        string path2 = @"C:\DB\Test.txt";
    
        Console.WriteLine(path1); // C:\DB\Test.txt
        Console.WriteLine(path2); // C:\DB\Test.txt
        Console.Read();
    }

其他转移字符：

<table> 
 <thead> 
  <tr> 
   <th>转义序列</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\</td> 
   <td>\ 字符</td> 
  </tr> 
  <tr> 
   <td>'</td> 
   <td>' 字符</td> 
  </tr> 
  <tr> 
   <td>"</td> 
   <td>" 字符</td> 
  </tr> 
  <tr> 
   <td>\?</td> 
   <td>? 字符</td> 
  </tr> 
  <tr> 
   <td>\a</td> 
   <td>Alert 或 bell</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格键（Backspace）</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>换页符（Form feed）</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行符（Newline）</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>水平制表符 tab</td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td>垂直制表符 tab</td> 
  </tr> 
  <tr> 
   <td>\ooo</td> 
   <td>一到三位的八进制数</td> 
  </tr> 
  <tr> 
   <td>\xhh . . .</td> 
   <td>一个或多个数字的十六进制数</td> 
  </tr> 
 </tbody> 
</table>

### 【1.6】大写的String和小写的string ###

*  String是.Net Framework的类(在C\#的IDE中不会显示颜色)。
 *  string是C\#的关键字，也就是String类的别名，表示一种数据类型，映射为.Net Framwork中的String。
 *  使用string时编译器会把它编译成String。
 *  string关键字，不能作类、结构、枚举、常量、方法、属性的名称，而String不是关键字，可以作为名称。

### 【1.7】StringBuilder类的重要性 ###

<table> 
 <thead> 
  <tr> 
   <th>常用方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Append()</td> 
   <td>在尾巴追加</td> 
  </tr> 
  <tr> 
   <td>Insert()</td> 
   <td>在指定位置插入</td> 
  </tr> 
  <tr> 
   <td>Remove()</td> 
   <td>移除指定位置字符串</td> 
  </tr> 
  <tr> 
   <td>AppendFormat()</td> 
   <td>追加的同时格式化</td> 
  </tr> 
  <tr> 
   <td>Clear()</td> 
   <td>清空</td> 
  </tr> 
  <tr> 
   <td>Replace()</td> 
   <td>替换字符</td> 
  </tr> 
 </tbody> 
</table>

static void TestCode()
    {
        string data = "";
        data += "AB";
        data += "CD";
        data += "EF";
        Console.WriteLine(data);
        // 以上的程序执行过程：每次拼接都会重新开辟一个新的空间来重新存储组合后的值。
    
        // 解决方式：可以定义可变字符串，实现字符串的追加。
        // 常用的方法：Append、Insert、Remove、AppendFormat、clear..等。
        // 使用：如果高频的字符串拼接中首选，普通的简单拼接依然可以使用前面的方法。
        StringBuilder sb = new StringBuilder();
        sb.Append("AB"); // 追加
        sb.Append("BC"); // 追加
        sb.Append("EF"); // 追加
        Console.WriteLine(sb.ToString());
    
        sb.Clear(); // 清空
        for(int i = 0; i < 3; i++)
        {
            Console.Write($"请输入第{i + 1}个数据: ");
            sb.Append(Console.ReadLine());
        }
        Console.WriteLine(sb.ToString());
    
        sb.Clear(); // 清空
        sb.Insert(0, "AAAA"); // 插入
        sb.Insert(sb.Length, "BBBB"); // 插入
        Console.WriteLine(sb.ToString());
    
        sb.Remove(0, 4); // 移除
        Console.WriteLine(sb.ToString());
    
        Console.Read();
    }

## 二、数组(Array) ##

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。

![6d970f53dae9464399ce0fe79c5ff3d6.png][]

数组基本要素包含：

*  标识符：数组的名称。
 *  元 素：存放的数据。
 *  类 型：元素的数据类型。
 *  下 标：元素的索引(从0开始)。

### 【2.1】声明数组 ###

datatype[] arrayName;
    
    // datatype 用于指定被存储在数组中的元素的类型。
    // [ ] 指定数组的秩（维度）。秩指定数组的大小。
    // arrayName 指定数组的名称。

### 【2.2】赋值数组 ###

// 赋值方法一：通过使用索引号赋值给一个单独的数组元素
    double[] balance = new double[10];
    balance[0] = 4500.0;
    
    // 赋值方法二：可以在声明数组的同时给数组赋值
    double[] balance = { 2340.0, 4523.69, 3421.0};
    
    // 赋值方法三：可以创建并初始化一个数组
    double[] balance = { 2340.0, 4523.69, 3421.0};
    
    // 赋值方法四：以省略数组的大小
    double[] balance = { 2340.0, 4523.69, 3421.0};
    
    // 赋值方法五：可以赋值一个数组变量到另一个目标数组变量中
    int [] marks = new int[]  { 99,  98, 92, 97, 95};
    int[] score = marks;

### 【2.3】使用数组 ###

// 使用for循环遍历
    static void CodeTest()
    {
        int[] scoreArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        for (int i = 0; i < scoreArray.Length; i++)
        {
            Console.Write(scoreArray[i] + " "); // 打印结果：1 2 3 4 5 6 7 8 9 10
        }
    }
    
    // 使用foreach循环遍历
    static void CodeTest()
    {
        int[] scoreArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        foreach(int val in scoreArray)
        {
            Console.Write(val + " "); // 打印结果：1 2 3 4 5 6 7 8 9 10
        }
    }

数组中常用的方法：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Max</td> 
   <td>获取数组最大值</td> 
  </tr> 
  <tr> 
   <td>Min</td> 
   <td>获取数组最小值</td> 
  </tr> 
  <tr> 
   <td>Contains</td> 
   <td>判断某一个元素是否包含</td> 
  </tr> 
  <tr> 
   <td>Sum</td> 
   <td>求和</td> 
  </tr> 
  <tr> 
   <td>Count</td> 
   <td>求数组元素数</td> 
  </tr> 
  <tr> 
   <td>Reverse</td> 
   <td>逆置</td> 
  </tr> 
  <tr> 
   <td>IndexOf</td> 
   <td>获取指定元素匹配的第一个位置</td> 
  </tr> 
  <tr> 
   <td>LastIndexOf</td> 
   <td>获取指定元素匹配的最后第一个位置</td> 
  </tr> 
  <tr> 
   <td>Sort</td> 
   <td>排序</td> 
  </tr> 
 </tbody> 
</table>

### 【2.4】区分值类型变量和引用类型变量 ###

*  值类型变量，又被称为【基本数据类型变量】
 *  引用类型变量，又被称为【对象类型变量】

值类型代码：

static void CodeTest()
    {
        int A = 10;
        int B = 20;
        Console.WriteLine("A: " + A); 	// 10
        Console.WriteLine("B: " + B); 	// 20
        Console.WriteLine("----------------------");
    
        int C = A;
        C += 100;
        Console.WriteLine("C: " + C); 	// 110
        Console.WriteLine("----------------------");
    
        Console.WriteLine("A: " + A); 	// 10
        Console.WriteLine("B: " + B); 	// 20
    }
    
    // 值类型变量在传值时，传递的是变量的”副本“，而不是变量本身，变量修改后互相没有影响。
    // 常见的值类型：
    // int、float、double、decimal....等

引用类型代码：

static void CodeTest()
    {
        int[] arrayA = { 10, 20 };
        Console.WriteLine("A: " + arrayA[0]); // 10
        Console.WriteLine("B: " + arrayA[1]); // 20
        Console.WriteLine("----------------------");
    
        int[] arrayC = arrayA;
        arrayC[0] += 100;
        Console.WriteLine("C: " + arrayC[0]); // 110
        Console.WriteLine("----------------------");
    
        Console.WriteLine("A: " + arrayA[0]); // 110
        Console.WriteLine("B: " + arrayA[1]); // 20
    }
    
    // 引用类型变量在传值时，是将自己传递给他人，没有开辟新的控件 自己=变量地址/指针
    // 常见引用类型：
    // string字符串、数组、系统库中的各种类、自定义的类

注意：string字符串的底层是引用类型(.Net做了特殊包装，属于引用类型，但需要当值类型来使用)

## 三、动态数组 ##

在C\#中，ArrayList 是一个非泛型的对象集合，其大小会动态增加。它与Array相同，只是它的大小是动态增加的。

一个ArrayList可以用来添加未知数据，可能你并不知道的类型和数据的大小。

System.Collections 命名空间中包含的 ArrayList 类。ArrayList使用 new 关键字创建对象。

官方文档：[ArrayList 类 (System.Collections) | Microsoft Learn][ArrayList _ _System.Collections_ _ Microsoft Learn]

### 【3.1】动态数组简单应用 ###

static void CodeTest()
    {
        // 添加数据
        ArrayList arrayList = new ArrayList();
        arrayList.Add(1);
        arrayList.Add(2);
        arrayList.Add("New York");
        arrayList.Add("London");
    
        // 遍历
        for(int i = 0; i < arrayList.Count; i++)
        {
            Console.Write(arrayList[i].ToString() + " ");
        }
        Console.WriteLine();
    
        // 获取长度
        int arrayCount = arrayList.Count;
    
        // 转换为数组
        object[] objArray = arrayList.ToArray();
    
        // 添加数组
        string[] strS = { "AA", "BB", "CC", "DD" };
        arrayList.AddRange(strS);
    
        for (int i = 0; i < arrayList.Count; i++)
        {
            Console.Write(arrayList[i].ToString() + " ");
        }
        Console.WriteLine();
    
        // 查找某个元素
        bool bRet1 = arrayList.Contains("AA");
        bool bRet2 = arrayList.Contains("HH");
    
        // 指定位置插入元素
        arrayList.Insert(3, "插入值");
    
        for (int i = 0; i < arrayList.Count; i++)
        {
            Console.Write(arrayList[i].ToString() + " ");
        }
        Console.WriteLine();
    
        // 移除元素
        arrayList.Remove("插入值");
        arrayList.RemoveAt(2);
    
        for (int i = 0; i < arrayList.Count; i++)
        {
            Console.Write(arrayList[i].ToString() + " ");
        }
        Console.WriteLine();
    
        arrayList.Clear();
    }

### 【3.2】动态数组常用属性和方法 ###

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Capacity</td> 
   <td>获取或设置ArrayList可以包含的元素数。</td> 
  </tr> 
  <tr> 
   <td>Count</td> 
   <td>获取ArrayList中实际包含的元素数。</td> 
  </tr> 
  <tr> 
   <td>IsFixedSize</td> 
   <td>获取一个值，该值指示 ArrayList 是否具有固定大小。</td> 
  </tr> 
  <tr> 
   <td>IsReadOnly</td> 
   <td>获取一个值，该值指示ArrayList是否为只读。</td> 
  </tr> 
  <tr> 
   <td>Item</td> 
   <td>获取或设置指定索引处的元素。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Add()/AddRange()</td> 
   <td>Add ()方法在 ArrayList 的末尾添加单个元素。AddRange ()方法将指定集合中的所有元素添加到 ArrayList 中。</td> 
  </tr> 
  <tr> 
   <td>Insert()/InsertRange()</td> 
   <td>Insert ()方法在 ArrayList 中的指定索引处插入单个元素。InsertRange ()方法从 ArrayList 中的指定索引开始插入指定集合的所有元素。</td> 
  </tr> 
  <tr> 
   <td>Remove()/RemoveRange()</td> 
   <td>Remove ()方法从 ArrayList 中删除指定的元素。RemoveRange ()方法从 ArrayList 中删除指定范围的元素。</td> 
  </tr> 
  <tr> 
   <td>RemoveAt()</td> 
   <td>从 ArrayList 中移除指定索引处的元素。</td> 
  </tr> 
  <tr> 
   <td>Sort()</td> 
   <td>对 ArrayList 的所有元素排序。</td> 
  </tr> 
  <tr> 
   <td>Reverse()</td> 
   <td>反转整个 ArrayList 中元素的顺序。</td> 
  </tr> 
  <tr> 
   <td>Contains</td> 
   <td>检查指定的元素是否存在于 ArrayList 中。如果存在则返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td>Clear</td> 
   <td>移除 ArrayList 中的所有元素。</td> 
  </tr> 
  <tr> 
   <td>CopyTo</td> 
   <td>将所有元素或元素范围复制到可编译数组。</td> 
  </tr> 
  <tr> 
   <td>GetRange</td> 
   <td>从 ArrayList 返回指定索引中指定的元素数。</td> 
  </tr> 
  <tr> 
   <td>IndexOf</td> 
   <td>搜索指定的元素，如果找到，则返回从零开始的索引。如果找不到元素，则返回-1。</td> 
  </tr> 
  <tr> 
   <td>ToArray</td> 
   <td>从ArrayList返回 数组。</td> 
  </tr> 
 </tbody> 
</table>

## 四、常量 ##

常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量，常量可以被当作常规的变量，只是它们的值在定义后不能被修改。

static void CodeTest()
    {
        // 定义变量
        int value = 10;
        value = 100;  // 变量是可以被修改的。
    
        // 定义常量
        const int VALUE = 10;
        VALUE = 100;  // 报错了：赋值号左边必须是变量、属性和索引器。
    }

## 五、枚举(Enum) ##

枚举是一组命名整型常量。枚举类型是使用 **enum** 关键字声明的，C\# 枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。

枚举作用：可以用来定义 “有限个变量值”，方便选择使用，避免出错。

枚举特点：可以表示一组描述性的名称，还可以有对应的 “整数值”。

### 【5.1】枚举类型声明 ###

enum <enum_name>
    { 
        enumeration list 
    };
    
    // enum_name 指定枚举的类型名称。
    // enumeration list 是一个用逗号分隔的标识符列表。

### 【5.2】常见的系统枚举 ###

namespace System
    {
        // 摘要: 
        //     指定一周中的某天。
        [Serializable]
        [ComVisible(true)]
        public enum DayOfWeek
        {
            Sunday = 0,
            Monday = 1,
            Tuesday = 2,
            Wednesday = 3,
            Thursday = 4,
            Friday = 5,
            Saturday = 6,
        }
    }
    
    // 结合代码：
    static void CodeTest()
    {
        DayOfWeek week = DayOfWeek.Friday;
        switch (week)
        {
            case DayOfWeek.Friday:
                Console.WriteLine("今天是星期日");
                break;
            case DayOfWeek.Monday:
                Console.WriteLine("今天是星期一");
                break;
            case DayOfWeek.Saturday:
                Console.WriteLine("今天是星期二");
                break;
            case DayOfWeek.Sunday:
                Console.WriteLine("今天是星期三");
                break;
            case DayOfWeek.Thursday:
                Console.WriteLine("今天是星期四");
                break;
            case DayOfWeek.Tuesday:
                Console.WriteLine("今天是星期五");
                break;
            case DayOfWeek.Wednesday:
                Console.WriteLine("今天是星期六");
                break;
            default:
                break;
        }
    }

### 【5.3】枚举类型的转化 ###

枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值。默认情况下，第一个枚举符号的值是 0。

// 比如说：
    enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
    =
    enum Days { Sun = 0, Mon, tue, Wed, thu, Fri, Sat };

*  获取枚举的常量名

Days nDay = Days.Mon;

*  获取枚举类型的常量值

int iDay = Convert.ToInt32(Days.Mon);

*  通过字符串获取枚举类型的常量名

string str = "Wed";
    Days toiDay = (Days)Enum.Parse(typeof(Days), str);

*  通常数值获取枚举类型的常量值

int iVal = 2;
    string tosDay = Enum.GetName(typeof(Days), iVal);

*  通过枚举类型，获取所有常量名的字符串数组

string[] tosDays = Enum.GetNames(typeof(Days));

[6d970f53dae9464399ce0fe79c5ff3d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/38d8dcdaca784157ae8689e1289e8034.png
[ArrayList _ _System.Collections_ _ Microsoft Learn]: https://learn.microsoft.com/zh-cn/dotnet/api/system.collections.arraylist?view=netframework-4.8&devlangs=csharp&f1url=%3FappId%3DDev16IDEF1%26l%3DZH-CN%26k%3Dk%28System.Collections.ArrayList%29%3Bk%28TargetFrameworkMoniker-.NETFramework%2CVersion%3Dv4.8%29%3Bk%28DevLang-csharp%29%26rd%3Dtrue