1
2
3
4
5
6

int age = 25;                // 整型
float price = 19.99f;        // 单精度浮点（需加 f 后缀）
double pi = 3.14159;         // 双精度浮点
bool isActive = true;        // 布尔值
char grade = 'A';            // 单个字符
decimal salary = 5000.00m;   // 高精度十进制（财务计算用，需加 m 后缀）

1
2
3

string name = "张三";        // 字符串（不可变）
int[] numbers = { 1, 2, 3 }; // 数组
object obj = "任何类型";     // 所有类型的基类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 隐式转换（小范围 → 大范围）
int x = 10;
long y = x;

// 显式转换（大范围 → 小范围，可能丢失精度）
double d = 3.14;
int i = (int)d;              // i = 3

// Convert 类（字符串 → 数值）
string text = "123";
int num = Convert.ToInt32(text);

// TryParse（安全转换，不会抛异常）
if (int.TryParse("456", out int result))
    Console.WriteLine(result);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int a = 10, b = 3;

// 算术运算
int sum = a + b;      // 13
int div = a / b;      // 3，整数除法结果截断
int mod = a % b;      // 1，取余

// 比较运算
bool eq = a == b;     // false
bool ne = a != b;     // true

// 逻辑运算
bool and = true && false;   // false，&& 左侧 false 则右侧不执行
bool or = true || false;    // true
bool not = !true;           // false

// null 处理运算符
string name = null;
string display = name ?? "默认值";      // name 为 null，取"默认值"
int? length = name?.Length;             // name 为 null，length 也为 null

// 三元运算符
string result = a > b ? "更大" : "更小";  // 条件 ? 真值 : 假值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// if/else
int score = 85;
if (score >= 90)
    Console.WriteLine("优秀");
else if (score >= 60)
    Console.WriteLine("及格");
else
    Console.WriteLine("不及格");

// switch 语句（支持模式匹配）
string status = "admin";
switch (status)
{
    case "admin":
        Console.WriteLine("管理员");
        break;
    case "user":
        Console.WriteLine("普通用户");
        break;
    default:
        Console.WriteLine("未知");
        break;
}

// switch 表达式（C# 8+ 新语法，更简洁）
string level = status switch
{
    "admin" => "管理员",
    "user" => "普通用户",
    _ => "未知"     // _ 表示默认情况
};

// for 循环（已知次数时使用）
for (int i = 0; i < 5; i++)
    Console.WriteLine(i);

// foreach 循环（遍历集合，只读）
int[] arr = { 1, 2, 3 };
foreach (var item in arr)
    Console.WriteLine(item);

// while 循环（不确定次数时使用）
int n = 0;
while (n < 3)
{
    Console.WriteLine(n);
    n++;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

string s1 = "Hello";
string s2 = "World";

// 拼接字符串
string result = s1 + " " + s2;             // Hello World，产生新字符串
string result2 = $"{s1} {s2}";             // 字符串插值，推荐写法

// StringBuilder（大量拼接时使用，避免 GC 压力）
var sb = new StringBuilder();
for (int i = 0; i < 100; i++)
    sb.Append(i).Append(", ");             // 不会创建临时字符串
string big = sb.ToString();

// 常用方法
string text = "  Hello World  ";
text.Length;                    // 获取长度
text.Trim();                    // 去除首尾空格
text.ToLower();                 // 转小写
text.ToUpper();                 // 转大写
text.Contains("World");         // 判断是否包含子串
text.StartsWith("Hello");       // 判断是否以指定字符开头
text.Replace("World", "C#");    // 替换子串
text.Split(' ');                // 按字符分割为数组
text.Substring(2, 5);           // 取子串，从索引 2 开始取 5 个字符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 定义 Person 类
public class Person
{
    // 字段（私有，外部不可访问）
    private string name;

    // 属性（推荐用属性代替公开字段）
    public string Name { get; set; }           // 自动属性，编译器生成背后字段
    public int Age { get; private set; }       // 外部只能读，内部可设置

    // 表达式体属性（只读）
    public bool IsAdult => Age >= 18;

    // 构造函数（创建对象时初始化）
    public Person(string name, int age)
    {
        Name = name;      // 通过属性赋值
        Age = age;
    }

    // 实例方法
    public void Introduce()
    {
        Console.WriteLine($"我是{Name}，{Age}岁");
    }

    // 静态成员（属于类，不属于对象）
    public static string Species = "人类";
}

// 使用类
var p = new Person("张三", 25);  // new 创建实例，调用构造函数
p.Introduce();                    // 调用实例方法
Console.WriteLine(Person.Species); // 通过类名访问静态成员

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class BankAccount
{
    // 私有字段（外部无法直接访问 balance）
    private decimal balance;

    // 属性：提供受控的访问入口
    public decimal Balance
    {
        get { return balance; }          // 读取时直接返回字段
        private set { balance = value; } // 写入权限限制为私有，外部不能改
    }

    // 带验证的属性
    private string accountNumber;
    public string AccountNumber
    {
        get => accountNumber;             // 表达式体 get
        set
        {
            if (value.Length != 10)
                throw new ArgumentException("账号必须10位");
            accountNumber = value;
        }
    }

    // 通过公开方法暴露可受控的操作
    public void Deposit(decimal amount)
    {
        if (amount <= 0) return;          // 业务规则校验
        balance += amount;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 基类
public class Animal
{
    public string Name { get; set; }

    public Animal(string name)  // 父类构造函数
    {
        Name = name;
    }

    // virtual 标记：子类可重写此方法
    public virtual void Speak()
    {
        Console.WriteLine("...");  // 默认实现
    }
}

// Dog 继承 Animal
public class Dog : Animal
{
    // base(name) 调用父类构造函数，传入 name
    public Dog(string name) : base(name) { }

    // override 重写父类的 Speak 方法
    public override void Speak()
    {
        Console.WriteLine("汪汪！");
    }
}

// sealed 类禁止被继承
public sealed class Cat : Animal
{
    public Cat(string name) : base(name) { }

    public override void Speak()
    {
        Console.WriteLine("喵~");
    }
}
// class Tiger : Cat { }  // 编译错误，Cat 是 sealed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 方法重载：同名方法，参数不同
public class Calculator
{
    public int Add(int a, int b) => a + b;         // 两个 int
    public double Add(double a, double b) => a + b; // 两个 double
    public int Add(int a, int b, int c) => a + b + c; // 三个 int
}

// 抽象类：包含未实现的抽象方法
public abstract class Shape
{
    public abstract double GetArea();  // 抽象方法，子类必须 override
}

// 接口：纯方法声明
public interface IDrawable
{
    void Draw();  // 接口方法隐式 public abstract
}

// 一个类可同时继承抽象类并实现多个接口
public class Circle : Shape, IDrawable
{
    public double Radius { get; set; }

    public override double GetArea() => Math.PI * Radius * Radius;
    public void Draw() => Console.WriteLine("画圆形");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 泛型类：T 是类型参数
public class Stack<T>
{
    private T[] items = new T[10];
    private int index = 0;

    public void Push(T item) => items[index++] = item;
    public T Pop() => items[--index];
}
// 使用：Stack<int> intStack = new Stack<int>();  // T 被替换为 int

// 泛型方法
public T Max<T>(T a, T b) where T : IComparable  // T 必须实现 IComparable
{
    return a.CompareTo(b) > 0 ? a : b;
}

// 泛型约束
public class Repository<T> where T : class, new()  // T 必须是引用类型且有无参构造
{
    public T Create() => new T();  // 因为 new() 约束，可安全调用 new T()
}

// 协变 out：T 只能出现在返回值（只读）
public interface IProducer<out T> { T Produce(); }
// IProducer<Dog> 可视为 IProducer<Animal>（Dog 是 Animal 的子类）

// 逆变 in：T 只能出现在参数（只写）
public interface IConsumer<in T> { void Consume(T item); }
// IConsumer<Animal> 可视为 IConsumer<Dog>（取 Animal 的消费者也能消费 Dog）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 自定义委托（定义方法的"签名"）
public delegate void LogHandler(string message);

// 内置委托：无需自定义，直接用 Action/Func
Action<string> log = msg => Console.WriteLine(msg);   // Action 无返回值
Func<int, int, int> add = (a, b) => a + b;            // Func<in, in, out> 有返回值

// 多播委托：一个委托绑定多个方法
LogHandler handler = Console.WriteLine;          // 第一个方法
handler += msg => File.WriteAllText("log.txt", msg);  // 再追加一个
handler("执行完毕");  // 两个方法依次执行

// 事件：类内部触发，外部只能订阅/取消
public class Button
{
    public event EventHandler Clicked;  // 声明事件

    public void Click()
    {
        Console.WriteLine("按钮被点击");
        Clicked?.Invoke(this, EventArgs.Empty);  // 只能在类内部触发
    }
}

// 使用事件
var btn = new Button();
btn.Clicked += (sender, args) => Console.WriteLine("事件处理");  // 订阅
btn.Click();  // 触发事件
btn.Clicked -= (sender, args) => Console.WriteLine("事件处理");  // 取消订阅
// btn.Clicked?.Invoke(null, null);  // 编译错误！事件不能在外部触发

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Lambda 表达式
Func<int, int> square = x => x * x;              // 单参数，省略括号
Func<int, int, bool> equals = (x, y) => x == y;  // 多参数，需要括号

// LINQ 方法语法
int[] numbers = { 5, 2, 8, 1, 9, 3 };

var evenNumbers = numbers.Where(n => n % 2 == 0);              // 筛选偶数 → [2, 8]
var sorted = numbers.OrderBy(n => n);                          // 升序排序
var top3 = numbers.OrderByDescending(n => n).Take(3);          // 前3大 → [9, 8, 5]
var sum = numbers.Sum();                                       // 求和 → 28
var hasBig = numbers.Any(n => n > 7);                          // 是否有 >7 的元素 → true

// LINQ 查询语法（类 SQL，编译器转为方法语法）
var query = from n in numbers
            where n > 3
            orderby n descending
            select n;
// 等价于：numbers.Where(n => n > 3).OrderByDescending(n => n)

// 实际应用：对象集合复杂查询
var students = new List<Student>
{
    new Student { Name = "张三", Score = 85 },
    new Student { Name = "李四", Score = 92 },
    new Student { Name = "王五", Score = 67 }
};

var passed = students
    .Where(s => s.Score >= 60)              // 筛选及格学生
    .OrderByDescending(s => s.Score)        // 按分数降序
    .Select(s => $"{s.Name}: {s.Score}");   // 投影为字符串
// 结果：["李四: 92", "张三: 85", "王五: 67"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

try
{
    int x = 10;
    int y = 0;
    int result = x / y;  // 抛出 DivideByZeroException
}
catch (DivideByZeroException ex)   // 先捕获具体异常
{
    Console.WriteLine($"除零异常：{ex.Message}");
}
catch (Exception ex)               // 再捕获所有其他异常
{
    Console.WriteLine($"通用异常：{ex.Message}");
}
finally                            // 不管有没有异常都执行
{
    Console.WriteLine("清理资源：关闭文件、断开连接等");
}

// using 语句：自动释放非托管资源
using (var reader = new StreamReader("file.txt"))
{
    string content = reader.ReadToEnd();
}  // 离开 using 块自动调用 reader.Dispose()

// using 声明（C# 8+）：更简洁的写法
using var writer = new StreamWriter("log.txt");
writer.WriteLine("日志内容");
// 离开作用域时自动释放，无需缩进嵌套

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// async/await 核心用法
public async Task<string> FetchDataAsync()
{
    using var client = new HttpClient();
    string result = await client.GetStringAsync("https://api.example.com");
    // await 期间线程不会被阻塞，可处理其他请求
    return result;
}

// 并行执行多个任务（比串行快一倍）
public async Task ProcessAllAsync()
{
    var task1 = FetchDataAsync();  // 任务已开始执行
    var task2 = FetchDataAsync();  // 第二个任务也开始了

    // 等待所有任务完成
    await Task.WhenAll(task1, task2);

    // 或等待任意一个先完成（如竞态请求）
    var first = await Task.WhenAny(task1, task2);
    Console.WriteLine(first.Result);
}

// 异步 Lambda
Button clickHandler = async (sender, args) =>
{
    await Task.Delay(1000);  // 异步等待1秒，不阻塞 UI 线程
    Console.WriteLine("一秒后执行");
};

// 异步流：逐个异步产生数据项
public async IAsyncEnumerable<int> GenerateNumbersAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(100);  // 模拟异步延迟
        yield return i;         // 逐个返回
    }
}

// 消费异步流
await foreach (var num in GenerateNumbersAsync())
    Console.WriteLine(num);  // 每100ms输出一个数字

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System.Reflection;

// 获取 Type 对象的两种方式
Type type = typeof(Person);            // 编译时已知类型
// Type type = obj.GetType();          // 运行时获取对象类型

// 遍历类型的公开属性
foreach (var prop in type.GetProperties())
    Console.WriteLine($"{prop.Name}: {prop.PropertyType}");

// 动态创建实例（无需编译时知道类型名）
object obj = Activator.CreateInstance(type);

// 动态调用方法
MethodInfo method = type.GetMethod("Introduce");
method.Invoke(obj, null);              // 在 obj 上执行 Introduce()

// 自定义特性
[AttributeUsage(AttributeTargets.Class)]  // 指定此特性可应用的目标
public class DisplayNameAttribute : Attribute
{
    public string Name { get; }
    public DisplayNameAttribute(string name) => Name = name;
}

// 使用自定义特性
[DisplayName("人员类")]
public class Employee { }

// 读取特性（运行时）
var attr = typeof(Employee).GetCustomAttribute<DisplayNameAttribute>();
Console.WriteLine(attr?.Name);  // 输出 "人员类"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// List：动态数组，索引访问
List<string> names = new List<string> { "张三", "李四" };
names.Add("王五");                // 添加
names.Remove("李四");             // 移除
names[0] = "赵六";               // 索引访问

// Dictionary：键值对，快速查找
Dictionary<string, int> scores = new()
{
    ["张三"] = 85,
    ["李四"] = 92
};
scores.TryGetValue("张三", out int score);  // 安全取值，不存在返回 false

// HashSet：唯一元素集合
HashSet<int> set = new() { 1, 2, 3, 3, 3 };  // 重复元素自动忽略 → { 1, 2, 3 }
set.Add(4);
bool exists = set.Contains(2);  // true，O(1) 查找

// Queue：先进先出
Queue<string> queue = new();
queue.Enqueue("第一个");
queue.Enqueue("第二个");
string first = queue.Dequeue();  // "第一个"（先入先出）

// Stack：后进先出
Stack<string> stack = new();
stack.Push("底部");
stack.Push("顶部");
string top = stack.Pop();  // "顶部"（后入先出）

// 线程安全集合
ConcurrentBag<int> bag = new();
Parallel.For(0, 100, i => bag.Add(i));  // 多线程安全添加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 值类型（struct）
public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}
// 值类型赋值是复制：Point p2 = p1;  // 独立副本

// 引用类型（class）
// 引用类型赋值是共享引用：Person p2 = p1;  // 指向同一对象

// 弱引用（允许 GC 回收）
WeakReference weakRef = new WeakReference(new Person("临时", 1));

// IDisposable 模式
public class ResourceHolder : IDisposable
{
    private bool disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
                // 释放托管资源
            // 释放非托管资源
            disposed = true;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 读写文本文件
string content = File.ReadAllText("input.txt");           // 全部读取
string[] lines = File.ReadAllLines("input.txt");          // 按行读取
File.WriteAllText("output.txt", "新内容");                 // 覆盖写入
File.AppendAllText("log.txt", "追加内容");                 // 追加写入

// Stream 方式（适合大文件）
using (var reader = new StreamReader("bigfile.txt"))
{
    string line;
    while ((line = reader.ReadLine()) != null)
        Console.WriteLine(line);
}

// JSON 序列化（System.Text.Json）
var person = new Person { Name = "张三", Age = 25 };
string json = JsonSerializer.Serialize(person);
var restored = JsonSerializer.Deserialize<Person>(json);

// 传统 JSON 序列化（Newtonsoft.Json / Json.NET）
// string json = JsonConvert.SerializeObject(person);
// var restored = JsonConvert.DeserializeObject<Person>(json);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// ASP.NET Core Web API 最小示例
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/hello", () => "Hello World");
app.MapPost("/user", (User user) => Results.Created($"/user/{user.Id}", user));

app.Run();

// Entity Framework Core（ORM）
// 定义实体
public class Blog
{
    public int Id { get; set; }
    public string Title { get; set; }
    public List<Post> Posts { get; set; }
}

// 定义上下文
public class AppDbContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer("连接字符串");
}

// 使用 EF Core
using var db = new AppDbContext();
var blogs = db.Blogs.Where(b => b.Title.Contains("C#")).ToList();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 注册服务（ASP.NET Core 启动时）
builder.Services.AddSingleton<ILogger, FileLogger>();     // 单例（全局唯一）
builder.Services.AddScoped<IService, MyService>();        // 作用域（每次请求）
builder.Services.AddTransient<IHelper, MyHelper>();       // 临时（每次注入都创建）

// 构造函数注入
public class UserController
{
    private readonly IUserService userService;

    public UserController(IUserService userService)
    {
        this.userService = userService;
    }
}

// 配置读取
public class MyConfig
{
    public string ConnectionString { get; set; }
}

// 读取配置
var config = builder.Configuration
    .GetSection("Database")
    .Get<MyConfig>();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 1. foreach 中不要修改集合
var list = new List<int> { 1, 2, 3 };
// foreach (var i in list) list.Remove(i);   // 抛异常！
for (int i = list.Count - 1; i >= 0; i--)
    list.RemoveAt(i);                         // 正确方式

// 2. 字符串拼接用 StringBuilder
// 错误：大量循环中用 += 拼接
string s = "";
for (int i = 0; i < 10000; i++)
    s += i.ToString();    // 性能极差！

// 正确：用 StringBuilder
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
    sb.Append(i);
string result = sb.ToString();

// 3. 异步方法命名约定
// 方法名以 Async 结尾
public async Task<int> CalculateAsync() { ... }

// 4. 避免 async void（事件处理除外）
// 错误：public async void DoSomething() { ... }
// 正确：public async Task DoSomething() { ... }

// 5. null 检查
string name = GetName();
// 旧写法
if (name != null) Console.WriteLine(name.Length);
// 新写法（C# 6+）
Console.WriteLine(name?.Length);
// 或者用模式匹配（C# 9+）
if (name is not null) Console.WriteLine(name.Length);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 重载：同类中同名不同参
public class Calc
{
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
}

// 重写：父子类同名同参
public class Animal { public virtual void Speak() => Console.WriteLine("..."); }
public class Dog : Animal { public override void Speak() => Console.WriteLine("汪汪"); }

1
2
3
4
5
6
7

void ModifyRef(ref int x) { x += 10; }
void SetOut(out int x) { x = 100; }  // 必须赋值

int a = 5;
ModifyRef(ref a);  // a = 15

SetOut(out int b);  // b = 100，无需提前初始化

1
2
3

sealed class FinalClass { }           // 不可被继承
class Base { public virtual void Foo() { } }
class Derived : Base { sealed override void Foo() { } }  // 派生类不可再重写

1
2
3
4

Type type = typeof(Person);
object obj = Activator.CreateInstance(type);
MethodInfo method = type.GetMethod("SayHello");
method.Invoke(obj, null);

1
2
3
4
5
6
7

class MyClass
{
    static MyClass()  // 静态构造函数，类首次被加载时执行一次
    {
        Console.WriteLine("静态初始化");
    }
}

1
2
3
4
5
6
7

// 委托：可任意 Invoke
public Action Notify;
Notify?.Invoke();  // 外部可以直接调用

// 事件：只能类内部 Invoke，外部只能 += / -=
public event Action Notified;
Notified?.Invoke();  // 仅限声明类内部调用

1
2
3
4
5
6

int i = 123;
object o = i;        // 装箱：i 复制到堆上
int j = (int)o;      // 拆箱：堆上数据复制回栈

// 性能开销：内存分配 + 复制
// 避免：使用泛型集合代替 ArrayList

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// for：通过索引访问，可修改集合
for (int i = 0; i < list.Count; i++) { list[i] = ...; }

// foreach：通过迭代器只读遍历，不能修改集合结构
foreach (var item in list) { Console.WriteLine(item); }

// 迭代器原理
// 1. 集合实现 IEnumerable 接口，提供 GetEnumerator()
// 2. GetEnumerator() 返回 IEnumerator
// 3. 每次循环调用 MoveNext()，返回 true 则通过 Current 获取元素

1
2
3
4
5
6

var enumerator = list.GetEnumerator();
while (enumerator.MoveNext())
{
    var item = enumerator.Current;
    // 循环体
}

1
2
3
4
5
6
7
8
9

// 内部结构
private struct Entry {
    public int hashCode;    // 哈希码（-1 表示空）
    public int next;        // 链表下一节点索引
    public TKey key;
    public TValue value;
}
private int[] buckets;      // 桶数组，存链表头索引
private Entry[] entries;    // 所有键值对

1
2
3
4
5
6
7
8
9

// 非泛型：需装箱拆箱
ArrayList list = new ArrayList();
list.Add(123);           // 装箱
int val = (int)list[0];  // 拆箱 + 类型转换

// 泛型：无需转换
List<int> list = new List<int>();
list.Add(123);
int val = list[0];

1
2
3
4
5

unsafe
{
    int* p = &x;
    *p = 100;
}

1
2
3
4
5

用户交互 → Controller（控制逻辑）
                ↓
         Model（数据处理）→ 数据库
                ↓
         View（界面显示）→ 响应用户

1
2
3
4
5
6

void ModifyRef(ref Person p)
{
    p.Name = "新名字";       // 修改原对象属性
    p = new Person("新对象"); // 重新赋值后，形参指向新对象
}
// 方法结束后，实参还是指向原始对象，但原始对象的属性已被修改

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Player : MonoBehaviour
{
    void Awake()    { }  // 对象加载时调用（仅一次），早于 Start
    void OnEnable() { }  // 每次启用时调用
    void Start()    { }  // 第一次 Update 前调用（仅一次）
    void Update()   { }  // 每帧调用
    void FixedUpdate() { }  // 固定时间间隔调用（物理更新）
    void LateUpdate() { }   // 所有 Update 完成后调用
    void OnDisable() { }    // 每次禁用时调用
    void OnDestroy() { }    // 销毁时调用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class CoroutineExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(DelayExecute());
    }

    IEnumerator DelayExecute()
    {
        Debug.Log("开始");
        yield return new WaitForSeconds(2f);  // 等待2秒
        Debug.Log("2秒后执行");

        yield return new WaitForEndOfFrame();  // 等待帧结束
        yield return new WaitForFixedUpdate(); // 等待物理帧更新
        yield return null;                     // 等待下一帧
    }

    // 停止协程
    void Stop()
    {
        StopCoroutine("DelayExecute");
        StopAllCoroutines();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class ObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject prefab;
    private Queue<GameObject> pool = new Queue<GameObject>();

    public GameObject Get()
    {
        if (pool.Count > 0)
        {
            GameObject obj = pool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        return Instantiate(prefab);
    }

    public void Return(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);  // 回收到池中
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// 普通单例
public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);  // 保证全局唯一
            return;
        }
        Instance = this;
        DontDestroyOnLoad(gameObject);  // 场景切换不销毁
    }
}

// 泛型单例基类
public class Singleton<T> : MonoBehaviour where T : Component
{
    public static T Instance { get; private set; }

    protected virtual void Awake()
    {
        if (Instance == null)
        {
            Instance = this as T;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// ❌ 错误：Update 中频繁拼接字符串产生大量 GC
void Update()
{
    string text = "HP: " + health + "/" + maxHealth;
    // 每次 Update 产生 3 个临时字符串对象
}

// ✅ 优化：使用 StringBuilder 或预先分配
private StringBuilder sb = new StringBuilder(64);

void Update()
{
    sb.Clear();
    sb.Append("HP: ").Append(health).Append("/").Append(maxHealth);
    text.text = sb.ToString();
}

// ✅ 或使用 string.Format（固定格式时）
text.text = $"HP: {health}/{maxHealth}";

1
2
3
4
5

// ❌ Unity 旧版本中 foreach 会产生 GC Alloc
foreach (var item in list) { }

// ✅ 改用 for 或 GetEnumerator 手动管理
for (int i = 0; i < list.Count; i++) { }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Player : MonoBehaviour
{
    [SerializeField] private int health;       // 私有字段在 Inspector 中显示
    [SerializeField] private GameObject prefab;

    [Range(0, 100)] public float speed;        // 滑动条限制范围
    [Tooltip("移动速度")] public float moveSpeed;  // 鼠标悬停提示
    [Header("攻击设置")]
    public int attackPower;
    public float attackRange;

    [HideInInspector] public int debugValue;   // 公开字段不在 Inspector 显示
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Player : MonoBehaviour
{
    // ❌ 每次调用都查找
    void Update()
    {
        GetComponent<Rigidbody>().AddForce(Vector3.up);
    }

    // ✅ 缓存引用
    private Rigidbody rb;

    void Awake()
    {
        rb = GetComponent<Rigidbody>();
    }

    void Update()
    {
        rb.AddForce(Vector3.up);
    }
}

1
2

if (TryGetComponent(out Rigidbody rb))
    rb.AddForce(Vector3.up);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// C# 事件（解耦）
public class HealthSystem : MonoBehaviour
{
    public event Action<float> OnHealthChanged;
    public event Action OnPlayerDied;

    private float health = 100;

    public void TakeDamage(float damage)
    {
        health -= damage;
        OnHealthChanged?.Invoke(health);
        if (health <= 0) OnPlayerDied?.Invoke();
    }
}

// 订阅事件
public class UIManager : MonoBehaviour
{
    [SerializeField] private HealthSystem player;

    void Start()
    {
        player.OnHealthChanged += UpdateHealthBar;
        player.OnPlayerDied += ShowGameOver;
    }

    void UpdateHealthBar(float health) { /* 更新血条 */ }
    void ShowGameOver() { /* 显示游戏结束 */ }

    void OnDestroy()
    {
        // 记得取消订阅，防止内存泄漏
        player.OnHealthChanged -= UpdateHealthBar;
        player.OnPlayerDied -= ShowGameOver;
    }
}

1
2
3
4
5
6
7
8
9

public class Button : MonoBehaviour
{
    public UnityEvent onClick;  // 可在编辑器拖拽绑定

    void OnMouseDown()
    {
        onClick?.Invoke();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// Resources 加载（简单但性能差）
GameObject prefab = Resources.Load<GameObject>("Prefabs/Player");
Instantiate(prefab);

// Resources 注意事项：
// - 所有 Resources 文件夹中的资源都会被打包，增加包体
// - 加载是同步的，大资源会卡帧
// - 已过时，推荐用 Addressables

// Addressables 加载（异步、按需加载）
AsyncOperationHandle<GameObject> handle =
    Addressables.LoadAssetAsync<GameObject>("Player");
handle.Completed += (op) =>
{
    Instantiate(op.Result);
};