using System;                 // 引入命名空间

namespace StudentManagerPro   // 定义命名空间
{
    class Program             // 定义类
    {
        static void Main()    // 程序入口方法
        {
            Console.WriteLine("Hello");
        }
    }
}

// 单行注释

/* 多行注释
   可跨越多行 */

/// <summary>
/// XML 文档注释，描述类和方法的用途，可被 IDE 智能提示读取
/// </summary>

int age = 20;              // 声明并赋值
string name;               // 先声明
name = "张三";             // 后赋值
const double PI = 3.14159; // 常量，声明后不可修改

int a = 10;
int b = a;      // b 是 a 的副本
b = 20;         // a 仍为 10

int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1;   // arr2 与 arr1 指向同一个数组
arr2[0] = 100;       // arr1[0] 也随之变为 100

var age = 20;              // 推断为 int
var name = "张三";         // 推断为 string
var list = new List<int>();

int? classId = null;
if (classId.HasValue)
{
    int id = classId.Value;
}

// ?? 空合并运算符：左边为 null 时取右边的默认值
int id2 = classId ?? 0;

// 隐式转换：小范围到大范围，自动完成
int a = 10;
double b = a;

// 显式转换（强制转换）：大范围到小范围，可能丢失精度
double c = 9.8;
int d = (int)c;                  // d = 9，小数部分被截断

// Parse：字符串转数值，格式错误会抛出异常
int e = int.Parse("123");

// TryParse：转换失败返回 false，不抛异常（推荐）
if (int.TryParse("123", out int f))
{
    // 转换成功，f = 123
}

// Convert：通用转换，null 转数值时返回 0
int g = Convert.ToInt32(reader["Age"]);

// ToString：任意类型转字符串
string s = 123.ToString();

public enum Gender
{
    男,
    女
}

Gender g = Gender.男;

int a = 10;
object obj = a;     // 装箱：值类型 → object
int b = (int)obj;   // 拆箱：object → 值类型，必须强制转换为原类型

int a = 10, b = 10;
Console.WriteLine(a == b);       // True，值比较

string s1 = "abc";
string s2 = "abc";
Console.WriteLine(s1 == s2);     // True，string 的 == 比较内容

Student stu1 = new Student();
Student stu2 = stu1;             // 指向同一对象
Student stu3 = new Student();
Console.WriteLine(stu1 == stu2); // True
Console.WriteLine(stu1 == stu3); // False，两个不同的对象

int result = 10 % 3;                           // 取余，结果为 1
string level = age >= 18 ? "成年" : "未成年";  // 条件运算符

if (age >= 18)
{
    // ...
}
else if (age >= 12)
{
    // ...
}
else
{
    // ...
}

// switch：按固定值分支
switch (classId)
{
    case 1:
        Console.WriteLine("软件1班");
        break;
    case 2:
        Console.WriteLine("软件2班");
        break;
    default:
        Console.WriteLine("未知班级");
        break;
}

// for：已知循环次数时使用
for (int i = 0; i < 10; i++) { }

// foreach：遍历集合，日常开发最常用
foreach (Student stu in studentList)
{
    Console.WriteLine(stu.StudentName);
}

// while：先判断后执行
while (reader.Read()) { }

// do-while：先执行一次再判断
do { } while (condition);

int[] scores = new int[5];            // 长度为 5 的数组
string[] names = { "张三", "李四" };  // 声明同时初始化
int first = scores[0];                // 下标从 0 开始
int len = scores.Length;              // 数组长度

List<Student> list = new List<Student>();
list.Add(new Student());          // 添加元素
list.Remove(stu);                 // 删除元素
int count = list.Count;           // 元素个数
Student first = list[0];          // 按下标访问
bool exist = list.Contains(stu);  // 判断是否包含

Dictionary<int, string> classMap = new Dictionary<int, string>();
classMap.Add(1, "软件1班");
string name = classMap[1];             // 按键取值
bool hasKey = classMap.ContainsKey(1); // 判断键是否存在

// 定义泛型类：同一套逻辑适配不同类型
public class Box<T>
{
    public T Content { get; set; }
}

// 使用时指定具体类型
Box<int> intBox = new Box<int>() { Content = 10 };
Box<string> strBox = new Box<string>() { Content = "文本" };

// 筛选年龄大于 20 的学员
List<Student> result = studentList.Where(s => s.Age > 20).ToList();

// 只取姓名，组成新集合
List<string> names = studentList.Select(s => s.StudentName).ToList();

// 查找学号为 1001 的学员，找不到返回 null
Student stu = studentList.FirstOrDefault(s => s.StudentId == 1001);

// 判断是否存在 2 班的学员
bool exists = studentList.Any(s => s.ClassId == 2);

// string.Format：占位符从 0 开始编号
string s1 = string.Format("姓名：{0}，年龄：{1}", name, age);

// $ 字符串插值（C# 6 及以上，推荐）：直接在字符串中嵌入变量
string s2 = $"姓名：{name}，年龄：{age}";

StringBuilder sb = new StringBuilder();
sb.Append("insert into Students ");
sb.Append("values(...)");
string sql = sb.ToString();

// 定义类
public class Student
{
    // 属性
    public int StudentId { get; set; }
    public string StudentName { get; set; }
    public int Age { get; set; }

    // 方法
    public string GetInfo()
    {
        return $"姓名：{StudentName}，年龄：{Age}";
    }
}

// 创建对象
Student stu = new Student();
stu.StudentName = "张三";
stu.Age = 20;

// 对象初始化器：创建对象的同时为属性赋值
Student stu2 = new Student()
{
    StudentName = "李四",
    Age = 22
};

// 自动属性：编译器自动生成背后的私有字段
public string StudentName { get; set; }

// 完整写法：可在访问器中加入校验等逻辑
private int age;
public int Age
{
    get { return age; }
    set
    {
        if (value < 0 || value > 150)
        {
            throw new Exception("年龄不合法");
        }
        age = value;
    }
}

// 受限访问：外部只读，仅类内部可写
public int StudentId { get; private set; }

// 返回值类型 方法名(参数列表)
public int Add(int a, int b)
{
    return a + b;
}

// void 表示无返回值
public void Show() { }

// 方法重载（Overload）：方法名相同、参数列表不同，编译器按实参自动匹配
public bool IsIdNoExistd(string idNo) { }
public bool IsIdNoExistd(string idNo, int studentId) { }

// 可选参数：带默认值的参数，调用时可省略
public void Search(string name = "", int age = 0) { }

// ref：交换两个变量的值
public void Swap(ref int a, ref int b)
{
    int temp = a; a = b; b = temp;
}
int x = 1, y = 2;
Swap(ref x, ref y);       // 调用处也要加 ref，执行后 x = 2，y = 1

// out：一个方法同时带回"是否成功"和"结果"两个值
public bool TryDivide(int a, int b, out int result)
{
    if (b == 0)
    {
        result = 0;
        return false;
    }
    result = a / b;
    return true;
}
if (TryDivide(10, 3, out int r))
{
    // 除法成功，r = 3
}

// params：接受任意个数的参数
public int Sum(params int[] numbers)
{
    int sum = 0;
    foreach (int n in numbers) sum += n;
    return sum;
}
Sum(1, 2, 3, 4);          // 直接传多个值，无需先组装数组

public class Student
{
    public Student() { }                   // 无参构造函数

    public Student(string name, int age)   // 带参构造函数
    {
        StudentName = name;
        Age = age;
    }
}

Student stu = new Student("张三", 20);

public class SQLHelper
{
    public static string connString = "...";

    public static int Update(string sql) { }
}

// 调用方式：类名.成员
SQLHelper.Update(sql);

// 父类
public class Person
{
    public string Name { get; set; }
    public void Eat() { }
}

// 子类：冒号表示继承
public class Student : Person
{
    public int StudentId { get; set; }
}

Student stu = new Student();
stu.Name = "张三";   // 继承自 Person
stu.Eat();           // 继承自 Person

public Student(string name) : base(name) { }   // 调用父类构造函数

public class Person
{
    public virtual void SayHello()
    {
        Console.WriteLine("我是人");
    }
}

public class Student : Person
{
    public override void SayHello()
    {
        Console.WriteLine("我是学生");
    }
}

Person p = new Student();
p.SayHello();   // 输出"我是学生"，由实际对象类型决定，而非引用类型

public abstract class Animal
{
    public string Name { get; set; }

    public void Eat()                     // 普通方法：包含实现，子类直接继承
    {
        Console.WriteLine("吃东西");
    }

    public abstract void MakeSound();     // 抽象方法：只有签名，子类必须实现
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("汪汪");
    }
}

// Animal a = new Animal();   // 错误：抽象类不能实例化
Animal dog = new Dog();       // 正确：父类引用指向子类对象

Person p = new Student();

if (p is Student)                 // 类型判断
{
    Student s = (Student)p;       // 强制转换
}

Student s2 = p as Student;        // 转换失败时 s2 为 null
if (s2 != null) { }

// C# 7 及以上支持模式匹配，判断与转换一步完成
if (p is Student s3)
{
    // 可直接使用 s3
}

public interface IStudentService
{
    int AddStudent(Student stu);      // 只有签名，没有方法体
    List<Student> GetStudents();
}

public class StudentService : IStudentService
{
    public int AddStudent(Student stu)
    {
        // 具体实现
    }

    public List<Student> GetStudents()
    {
        // 具体实现
    }
}

// 定义委托类型：约定方法的签名（参数与返回值）
public delegate void DataHandler(string data);

// 符合该签名的方法
public void ReceiveData(string data)
{
    Console.WriteLine("收到: " + data);
}

// 委托变量指向方法（注意方法名后不加括号，是取引用而非调用）
DataHandler handler = ReceiveData;
handler("张三");   // 调用委托 = 调用 ReceiveData("张三")

public class FrmAddStudent
{
    // 声明事件
    public static event DataHandler StudentChanged;

    // 触发方法：只有所属类内部可以触发事件
    public static void NotifyStudentChanged(string name)
    {
        if (StudentChanged != null)   // 触发前必须判空
        {
            StudentChanged(name);
        }
    }
}

// 订阅（在其他窗体中）
FrmAddStudent.StudentChanged += OnStudentChanged;

// 取消订阅（窗体关闭时必须执行，防止内存泄漏）
FrmAddStudent.StudentChanged -= OnStudentChanged;

// 匿名方法写法
list.Find(delegate(Student s) { return s.Age > 20; });

// Lambda 简写
list.Find(s => s.Age > 20);

// 订阅事件
btnSend.Click += (sender, e) => { MessageBox.Show("点击了"); };

try
{
    // 可能出错的代码
    int result = Convert.ToInt32(input);
}
catch (FormatException ex)
{
    // 捕获特定类型的异常
    MessageBox.Show($"格式错误：{ex.Message}");
}
catch (Exception ex)
{
    // 捕获所有异常，放在最后
    MessageBox.Show($"操作失败：{ex.Message}");
}
finally
{
    // 无论是否出错都会执行，通常用于释放资源
    conn.Close();
}

// 包装原始异常后重新抛出，为上层调用者提供更明确的错误信息
catch (Exception ex)
{
    throw new Exception("添加学员失败，数据库操作异常：" + ex.Message);
}

using (SqlConnection conn = new SqlConnection(connString))
{
    conn.Open();
    // 使用连接
}   // 离开 using 作用域时自动调用 conn.Dispose()

DateTime now = DateTime.Now;
string s1 = now.ToString("yyyy-MM-dd");          // 2026-10-17
string s2 = now.ToString("yyyy-MM-dd HH:mm:ss"); // 2026-10-17 18:30:00
DateTime weekLater = now.AddDays(7);             // 7 天后

// 计算周岁
int age = DateTime.Now.Year - birthday.Year;

using System.IO;

// 写入文本（覆盖原内容）
File.WriteAllText("log.txt", "第一行内容");

// 追加文本
File.AppendAllText("log.txt", "追加一行");

// 读取全部文本
string content = File.ReadAllText("log.txt");

// 按行读取为数组
string[] lines = File.ReadAllLines("log.txt");

// 判断文件是否存在
bool exists = File.Exists("log.txt");