// 反转数组
Array.Reverse(arr);

// 反转后再次输出
Console.WriteLine("\n反转后数组的元素及次序：");
for (int n = 0; n < arr.Length; n++)
{
    Console.WriteLine("[{0}] - {1}", n, arr[n]);
}
//反转数组
//Array.Reverse(xxx);

// 定义数组
byte[] arr = new byte[] { 5, 6, 7, 8 };
Console.WriteLine("反转前数组的元素及次序：");
for (int i = 0; i < arr.Length; i++)
{
    Console.WriteLine("[{0}] - {1}", i, arr[i]);
}

//更改数组的大小
public static void Resize<T>(ref T[] array,int newSize);//方法是通过替换旧数组修改数组的大小，哈希值是会不同的。
// 创建数组实例
int[] arr = new int[3];
// 修改大小前输出
Console.WriteLine("数组的大小：{0}，哈希值为{1}", arr.Length, arr.GetHashCode());
// 修改数组的大小
Array.Resize<int>(ref arr, 7);
// 修改大小后再次输出
Console.WriteLine("数组的大小：{0}，哈希值为{1}", arr.Length, arr.GetHashCode());

using System;

namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* 一个带有 5 行 2 列的数组 */
            int[,] a = new int[5, 2] {{0,0}, {1,2}, {2,4}, {3,6}, {4,8} };

            int i, j;
            char[,] arr2 = { { 'a', 'b', 'c', 'd' }, { 'e', 'f', 'g', 'h' }, { 'i', 'j', 'k', 'l' } };
               // 获取数组的行数和列数
            int rowCount = list.GetLength(0); // 获取行数，第一维度
            int colCount = list.GetLength(1); // 获取列数，第二维度

            /* 输出数组中每个元素的值 */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);
                }
            }
           Console.ReadKey();
        }
    }
}

//交错数组是数组的数组。交错数组是一维数组

//使用 Length 属性可以快速获取数组的总元素数量，适用于所有类型的数组。
//使用 GetLength 方法可以获取多维数组的特定维度的长度，更加精确。
int[][] arr = new int[2][]
{
    new int[]{ 10,20,30},
    new int[]{ 40,50,60,70}
};
for (int i = 0; i < arr.Length;i++)
{
    //arr[i].GetLength(0)
    for (int j = 0; j < arr[i].Length; j++)
        Console.WriteLine("{0},{1} = {2}", i,j, arr[i][j]);
    Console.WriteLine(" ");
}   
Console.WriteLine(arr.Rank);//1

// 三层嵌套的数组
int[][][] ints = new int[3][][] //第一层
{
    new int[2][] //第二层
    {
        new int[] { 20, 32, 2 }, //第三层
        new int[] { 1, 11, 29, 6 } //第三层
    },
    new int[2][] //第二层
    {
        new int[] { 27, 26, 17 }, //第三层
        new int[] { 199 } //第三层
    },
    new int[2][] //第二层
    {
        new int[] { 40, 74, 81 }, //第三层
        new int[] { 120, 95 } //第三层
    }
};
// 输出数组
Console.WriteLine(ints.GetType().Name);
for (int i = 0; i < ints.Length; i++) //第一层
{
    Console.WriteLine("  {0}", ints[i].GetType().Name);
    for (int j = 0; j < ints[i].Length; j++) //第二层
    {
        Console.WriteLine("    {0}", ints[i][j].GetType().Name);
        Console.Write("       ");
        for (int k = 0; k < ints[i][j].Length; k++) //第三层
        {
            Console.Write("{0} ", ints[i][j][k]);
        }
        Console.WriteLine();
    }
}

int[] list = { 34, 72, 13, 44, 25, 30, 10 };

Console.Write("原始数组： ");
foreach (int i in list)
{
    Console.Write(i + " ");
}
Console.Write();

 //初始为4，以后成倍递增
           ArrayList arrayList = new ArrayList();
           arrayList.Add(1);
           arrayList.Add(2);
           arrayList.Add(3);
           arrayList.Add(4);
           arrayList.Add(5);
           Console.WriteLine($"{arrayList.Capacity},{arrayList.Count}");//8 5


//RemoveAt,Remove
ArrayList list = new ArrayList();
// 添加int类型对象
list.Add(100);
// 添加double类型对象
list.Add(20.977d);
// 添加string类型对象
list.Add("hello");
// 添加long类型对象
list.Add(9800000L);

// 可以通过索引取得元素
// 要进行类型转换
// 取出来的元素的类型要与放入时对应
Console.WriteLine("[0] - {0}", (int)list[0]);
Console.WriteLine("[3] - {0}", (long)list[3]);
// 输出元素总个数
Console.WriteLine("元素个数：{0}", list.Count);
// 删除最后一个元素
list.RemoveAt(list.Count - 1);
// 删除后再次输出元素个数

//结构是值类型（System.ValueType派生），类是引用类型（System.Object派生）
struct Test_Struct{
                public int x;
                /*
                public Test_Struct(){//不能有无参构造
                }
                */
                public Test_Struct(int value){
                        x = value;
                }
                // 结构不能继承、派生，但可以实现接口
                //struct Sub_Test_Struct:Test_Struct{}
        }

//字段不能设定初始值
//可以忽略new运算符，但是忽略后只能使用字段，其他无法使用;类不可以忽略new
struct Teacher
{
    public int _age = 20;
    public int Id { get; set; }
    public string Name { get; set; }
    public void Read()
    {
        Console.WriteLine("read book");
    }
    public Teacher()
    {
        Console.WriteLine("hello,teacher");
    }
}
    Teacher t1;
    t1._age = 20;
    t1.Name = "30";
//t1.Read();
Console.WriteLine($"{t1._age}");

//枚举只支持这几类:int、uint、byte、sbyte、short、ushort、long、ulong（其实也就是int、byte、long、short这四类），默认是int类型

enum longEnum:Long {L1}//sizeof(longEnum)为8个字节

enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };//枚举得在主函数外部
static void Main(string[] args){
    dynamic s = Convert.ToInt32(day.tueday);
    Console.WriteLine(s);
}

//获取枚举的值类型,Enum为基类，
enum Test : ushort
{
    Value1 = 100,
    Value2 = 101,
    Value3 = 103
}

//GetValues方法返回的数组类型不是固定的，是动态决定的，使用var关键字

//public static Array GetValues(Type enumType);
var values = Enum.GetValues(typeof(Test));
// 输出这些枚举值
foreach (ushort v in values)
{
    Console.Write(v + "\t");
}

//获取枚举中各成员的名称
//两个方法:Enum.GetName,Enum.GetNames
//public static string? GetName(Type enumType, object value);
//public static string[] GetNames(Type enumType);

 var name = Enum.GetName(typeof(Test),Test.Value1);
 Console.WriteLine(name);

 var names = Enum.GetNames(typeof(Test));
 foreach (var item in names)
 {
     Console.Write(item + "\t");
 }

//枚举的位运算
//首先需要Flag特性，包含用&，去掉先用~然后再与运算.
[Flags]
enum Test
{
    /// <summary>
    /// 二进制0
    /// </summary>
    None = 0,
    /// <summary>
    /// 二进制1
    /// </summary>
    Music = 1,
    /// <summary>
    /// 二进制10
    /// </summary>
    Video = 2,
    /// <summary>
    /// 二进制100
    /// </summary>
    Text = 4
}
 // 变量v相当于二进制111
Test v = Test.Music | Test.Text | Test.Video;
// 检查变量v中是否包含Text
if ((v & Test.Text) == Test.Text)
{
    Console.WriteLine("变量v中包含了Text。");
}
else
{
    Console.WriteLine("变量v中不包含Text。");
}
// 从v中去掉Music
v = v & ~Test.Music;
// 检查一下是否还含有Music
if ((v & Test.Music) == Test.Music)
{
    Console.WriteLine("变量v中仍含有Music的值。");
}
else
{
    Console.WriteLine("变量v中不包含Music的值。");
}

Console.Read();

//如果用Flag特性的话，转换为带有Flag特性的可以转换，不带Flag特性的话是原值7

// 001 | 010 | 100 == 111，十进制值为7
int testValue = 7;
/*
 * 无法从组合的值中识别出A枚举
 */
Console.WriteLine((A)testValue);
/*
 * 可以从组合数值中识别出B枚举的值
 */
Console.WriteLine((B)testValue);

/*
StringBuilder对象维护缓冲区以容纳对字符串的扩展。
如果空间可用，则会将新数据追加到缓冲区;否则，将分配一个新的更大的缓冲区，将原始缓冲区中的数据复制到新缓冲区，然后将新数据追加到新缓冲区。
最大的容量是INT类型的最大值
*/

StringBuilder stringBuilder = new StringBuilder("abc", 40);
stringBuilder.Append(new char[] { 'D','E','F'});
Console.WriteLine(stringBuilder);//abcDEF

/*
常用方法
Regex.Match: 查找字符串中第一个匹配的正则表达式。
Regex.Matches: 查找字符串中所有匹配的正则表达式，返回一个 MatchCollection。
Regex.Replace: 替换字符串中匹配的正则表达式。
Regex.IsMatch: 检查字符串是否与正则表达式匹配。
*/

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        // 测试手机号
        string phoneNumber = "13812345678"; // 示例手机号
        if (IsValidPhoneNumber(phoneNumber))
        {
            Console.WriteLine($"{phoneNumber} 是有效的手机号。");
        }
        else
        {
            Console.WriteLine($"{phoneNumber} 不是有效的手机号。");
        }

        // 测试游戏账号
        string gameAccount = "Player123"; // 示例游戏账号
        if (IsValidGameAccount(gameAccount))
        {
            Console.WriteLine($"{gameAccount} 是有效的游戏账号。");
        }
        else
        {
            Console.WriteLine($"{gameAccount} 不是有效的游戏账号。");
        }
    }

    // 验证手机号
    static bool IsValidPhoneNumber(string phoneNumber)
    {
        // 中国大陆手机号正则表达式
        string pattern = @"^1[3-9]\d{9}$";
        return Regex.IsMatch(phoneNumber, pattern);
    }

    // 验证游戏账号
    static bool IsValidGameAccount(string gameAccount)
    {
        // 游戏账号正则表达式（字母开头，长度6-16，允许字母、数字和下划线）
        string pattern = @"^[a-zA-Z][a-zA-Z0-9_]{5,15}$";
        return Regex.IsMatch(gameAccount, pattern);
    }
}


string input = "1851 1999 1950 1905 2003";
string pattern = @"(?<=19)\d{2}\b";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine(match.Value);



using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "A Thousand Splendid Suns";

         Console.WriteLine("Matching words that start with 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}


using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}


using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = "Hello   World   ";
         string pattern = "\\s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}

     int a = 30;
     int b = 49;
     dynamic result = string.Format("{0},{1}", a, b);
     Console.WriteLine(result);

MyStruct my  = new MyStruct();
my.X = 20;
Console.WriteLine(string.Format($"{my.X}"));
Console.WriteLine(string.Format("{0}",my.X));
Console.WriteLine("{0}",my.X);
Console.WriteLine($"{my.X}");

       List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);
foreach(int i in list)
{
    Console.WriteLine(i);
};

using System
int age = 20;
Console.WriteLine(age);

record bird(string name,string sex) { }
static  void Main(string[] args)
{
    bird bird = new bird("小黄","公");
    //这种的只能在完整版里才可以
    bird bird = new bird{
        name = "小黄鸭"，
        sex = "男";
    }
}

public record Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}
Person p1 = new();
p1.Id = 1;
p1.Name = "dog";
p1.Age = 20;

Person p2 = new();
p2.Id = 1;
p2.Name = "dog";
p2.Age = 20;

if (p1 == p2)//record会自动计算，会给出true,而class会给出false
{
    Console.WriteLine("是同一个人");
}
else {
    Console.WriteLine("不是同一个人");
}

       //得先抛出throw才能进行捕获
        class DivideByZeroCustomException : Exception
        {
            public DivideByZeroCustomException(string message) : base(message)
            {
            }
        }
        static void Main(string[] args)
            {
                 
                try
                {
                int number = Convert.ToInt32(Console.ReadLine());
                int shuzi = Convert.ToInt32(Console.ReadLine());
                if (shuzi == 0)
                    throw (new DivideByZeroCustomException("爆零异常"));
                int result = number / shuzi;//这个只能在没有错误的情况下才能运行，放前面会有错误
                Console.WriteLine(result);
            }
                catch (DivideByZeroCustomException e)
                {
                Console.WriteLine(e.Message);
            }
                
                finally{
                    Console.WriteLine("请重新输入");
                };
          }




//when关键字后面是异常的筛选条件
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                //DoSomething(null, null);
                DoSomething("abc", null);
            }
            catch (ArgumentException ex) when (ex.ParamName == "y")
            {
                Console.WriteLine(ex.Message);
            }
            catch
            {
                Console.WriteLine("其他异常信息。");
            }

            Console.Read();
        }

        static void DoSomething(string x, string y)
        {
            if (string.IsNullOrWhiteSpace(x))
            {
                throw new ArgumentException("参数不能为空。", "x");
            }
            if (string.IsNullOrWhiteSpace(y))
            {
                throw new ArgumentException("参数不能为空。", "y");
            }
        }
    }

}