C#_装箱拆箱

# 概念

`partial` 关键字允许 **将一个类、结构体或接口的定义拆分到多个文件中**，在编译时，它们会被合并为一个完整的类型。



## 1. 为什么使用 `partial` ？
- **多人协作开发**：将类拆分到多个文件，避免多人修改同一个文件导致的冲突。
- **自动生成代码**：有些框架（如 **WinForms、Entity Framework**）会自动生成部分代码，而 `partial` 允许开发者在另一个文件中扩展该类，而不修改自动生成的代码。
- **提高代码可读性**：将大型类拆分成多个文件，提高代码组织性。

---

## 2. `partial` 关键字的用法
### 2.1 基本语法
多个 `partial` 关键字修饰的类在编译时会合并成一个完整的类。
> 拆分出来的类的所有类名必须保持一致！

#### **示例：拆分 `Player` 类**
📌 **Player_Part1.cs**  
```csharp
public partial class Player
{
    public string Name { get; set; }
    public int Health { get; set; }

    public void TakeDamage(int amount)
    {
        Health -= amount;
    }
}
```
📌 **Player_Part2.cs**  
```csharp
public partial class Player
{
    public void Heal(int amount)
    {
        Health += amount;
    }
}
```
📌 **使用 `Player` 类**  
```csharp
class Program
{
    static void Main()
    {
        Player player = new Player { Name = "Warrior", Health = 100 };
        player.TakeDamage(20);
        player.Heal(10);
        Console.WriteLine($"{player.Name} has {player.Health} HP.");
    }
}
```
✅ **编译后，`Player` 类的所有成员都会合并在一起**。

---

## 3. `partial` 的应用场景
### 3.1 **拆分大型类**
当类的代码量过大时，可以拆分到不同的 `partial` 文件，提高代码可读性和管理性。

### 3.2 **自动生成代码**（WinForms / EF）
在 **Windows 窗体应用程序（WinForms）** 中，设计器会生成 `.Designer.cs` 文件，开发者可以在主文件中扩展该类，而不影响自动生成的代码。

示例（**WinForms 自动生成部分**）：
📌 `Form1.Designer.cs`（自动生成的 UI 代码）  
```csharp
public partial class Form1 : Form
{
    private Button myButton;
    private void InitializeComponent()
    {
        this.myButton = new System.Windows.Forms.Button();
        this.myButton.Text = "Click Me";
    }
}
```
📌 `Form1.cs`（开发者扩展的逻辑代码）  
```csharp
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        myButton.Click += (s, e) => MessageBox.Show("Hello, World!");
    }
}
```
✅ **开发者的逻辑代码不会影响自动生成的 UI 代码**。

---

## 4. `partial` 的限制
- **必须在同一命名空间和程序集内**，不能跨程序集定义。
- **不能用于单个方法**，但可以用于 **类、结构体、接口**。
- **必须保持相同的访问修饰符**（`public`、`internal` 等）。
- **不能定义不同的基类**（即所有 `partial` 片段必须继承相同的基类或接口）。

---

## 5. `partial` 适用于结构体和接口
除了 **类（class）** 之外，`partial` 还可以用于 **结构体（struct）和接口（interface）**。

#### **示例：`partial struct`**  
```csharp
public partial struct Point
{
    public int X { get; set; }
}

public partial struct Point
{
    public int Y { get; set; }
}
```
✅ **结构体 `Point` 仍然是一个完整的结构体，包含 `X` 和 `Y` 两个属性**。

#### **示例：`partial interface`**  
```csharp
public partial interface IAnimal
{
    void Eat();
}

public partial interface IAnimal
{
    void Sleep();
}
```
✅ **接口 `IAnimal` 依然是一个完整的接口，包含 `Eat` 和 `Sleep` 两个方法**。

---

## 6. `partial` 和 `partial method`（分部方法）
**`partial method` 只允许在 `partial` 类或结构体中定义**，通常用于 **自动生成代码的占位**，如果没有实现，编译器会忽略它。

#### **示例：分部方法**  
```csharp
public partial class GameCharacter
{
    partial void OnDamageTaken(); // 声明分部方法
}

public partial class GameCharacter
{
    partial void OnDamageTaken() // 实现分部方法
    {
        Console.WriteLine("Character took damage!");
    }
}
```

C#_partial分部类

## 1. 什么是拓展方法？
拓展方法（Extension Methods）是 **C# 3.0** 引入的一种特性，允许 **在不修改原有类型代码的情况下，为现有类型（包括类、结构体、接口等）添加新的方法**。



## 2. 拓展方法的作用
- **对现有类型添加新方法**，无需修改该类型的源代码。
- **适用于第三方库或 `sealed` 类**（无法继承的类）。
- 使代码更简洁，避免使用静态工具类。
- **支持链式调用**，提高代码可读性。

## 3. 拓展方法的基本语法
### 3.1 定义拓展方法的规则
1. **必须是静态方法**。
2. **必须定义在静态类中**。
3. **第一个参数必须使用 `this` 关键字，指定要拓展的类型**。
4. **调用时不需要传入 `this` 参数**。

### 3.2 示例：为 `string` 类型添加 `ToInt` 方法
```csharp
using System;

public static class StringExtensions
{
    public static int ToInt(this string str)
    {
        int result;
        return int.TryParse(str, out result) ? result : 0;
    }
}

class Program
{
    static void Main()
    {
        string number = "123";
        int intValue = number.ToInt();
        Console.WriteLine(intValue); // 输出：123
    }
}
```

## 4. 调用规则
- **可以像实例方法一样调用**：
  ```csharp
  string text = "100";
  int value = text.ToInt();
  ```
- **也可以直接调用静态方法**：
  ```csharp
  int value = StringExtensions.ToInt("100");
  ```
- **扩展方法不会覆盖实例方法**，如果类型本身已经定义了相同名称的方法，则 **实例方法优先**。

## 5. 常见应用场景

### 5.1 拓展 `List<T>` 类型的方法（洗牌算法）
```csharp
using System;
using System.Collections.Generic;

public static class ListExtensions
{
    private static Random random = new Random();

    public static void Shuffle<T>(this List<T> list)
    {
        int n = list.Count;
        for (int i = 0; i < n; i++)
        {
            int j = random.Next(i, n);
            (list[i], list[j]) = (list[j], list[i]);
        }
    }
}
```

### 5.2 拓展 `DateTime` 类型的方法（计算年龄）
```csharp
using System;

public static class DateTimeExtensions
{
    public static int GetAge(this DateTime birthDate)
    {
        var today = DateTime.Today;
        int age = today.Year - birthDate.Year;
        if (birthDate > today.AddYears(-age)) age--;
        return age;
    }
}
```

### 5.3 拓展 `Enum` 类型的方法（获取描述）
```csharp
using System;
using System.ComponentModel;

public static class EnumExtensions
{
    public static string GetDescription(this Enum value)
    {
        var field = value.GetType().GetField(value.ToString());
        var attribute = (DescriptionAttribute)Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute));
        return attribute?.Description ?? value.ToString();
    }
}
```

C#_拓展方法

# 静态成员基本概念
* `static`关键字用于修饰成员变量、方法、属性等，称为静态成员。
* 静态成员的特点是：直接用类名点出使用。`Console.WriteLine` 就是静态成员的体现。



# 静态类
* 定义：
    * 类语句块外，namespace 语句块内。
    * 用`static`修饰的类。
* 特点：
    * 只能包含静态成员。
    * 不能被实例化。
* 作用：
    * 将常用的静态成员写在静态类中，方便使用。
    * 静态类不能被实例化，更能体现工具类的唯一性。
# 静态构造函数
* 定义：
    * 类语句块外，namespace语句块内
    * 在构造函数上加上`static`修饰
* 特点:
    * 静态类和普通类都可以有静态构造函数。
    * 不能使用访问修饰符。
    * 不能有参数。
    * 只会调用一次，在第一次访问该类的任何静态成员的时候都会触发静态构造函数执行。后续不在会调用；静态成员的生命周期伴随着程序的运行到终止。

C#_静态

# 作用
* 是一个函数参数的修饰符，解决值类型和引用类型的函数变量，在函数内部修改值时，能够影响外部传入的变量,让其也被修改
* 两者目的相同，使用的方式和表达的语义不同



# ref
* 使用ref修饰的参数，变量在赋值前必须在外部初始化，内部变量不强制要求修改

```c#
    void RefFunciton(ref int vaule)
    {
        vaule += 10;
    }
    int num = 5;
    RefFunciton(ref num);
    //输出15
    System.Console.WriteLine(num);
```
# out
* 使用out修饰的参数，变量在外部不用初始化，但是在内部必须赋值

```c#
    void OutFunciton(out int a, out int b)
    {
        a = 10;
        b = 20;
    }
    int x, y;
    OutFunciton(out x, out y);
    //输出x为10,y为20
    System.Console.WriteLine("x的值为{0},y的值为{1}", x, y);
```
* out参数也可以用于一个函数的多返回值，一个函数有多少个返回值,就定义多少个out参数,同时在外部定义对应数量的变量来接收即可

```c#
    int OutFunciton2(int a, out int b, out int c)
    {
        a = 10;
        b = 20;
        c = 30;
        return a;
    }
    int x = 0;
    int y, z;
    int x1 = OutFunciton2(x, out y, out z);
    Console.WriteLine("x的值为{0},y的值为{1},z的值为{2}", x1, y, z);
```
# 总结
`ref`和`out`的核心目的都是按引用传递参数，让方法可以修改调用者传入的变量，虽然两者本质上都是引用传递，但 `ref` 强调“修改已存在的值”，而 `out` 强调“返回新的值”。这也是为什么 `out` 参数在方法内部必须赋值，而 `ref` 参数不强制要求赋值