## 1. 定义方式
- **抽象类**：使用 `abstract` 关键字定义，不能被实例化，通常包含普通方法（有实现）和抽象方法（无实现）。
- **接口**：使用 `interface` 关键字定义，默认所有方法都是 `public` 且没有实现（C# 8.0 及以上支持默认实现）。



### 示例（C#）：
```csharp
// 抽象类
abstract class Animal
{
    public abstract void MakeSound(); // 抽象方法
    public void Sleep()               // 具体方法
    {
        Console.WriteLine("Sleeping...");
    }
}

// 接口
interface IAnimal
{
    void MakeSound(); // 只能定义方法签名（C# 8.0 之前）
}
```

---

## 2. 主要区别
| 特性 | 抽象类 | 接口 |
|------|--------|------|
| **字段** | 允许 | 不允许 |
| **构造函数** | 允许 | 不允许（不能被实例化） |
| **普通方法** | 允许 | 不允许（C# 8.0+ 允许默认实现） |
| **抽象方法** | 允许（不分抽象 | 只允许方法签名（完全抽象） |
| **访问修饰符** | 允许 `public/protected/private` |所有车成员默认 `public` |
| **继承方式**| 单继承|多继承

---


## 3. 适用场景
- **抽象类**：
  - 适用于有**共享代码**的情况，允许部分实现（如 `Sleep()`）。
  - 适合定义**一类对象的基本行为**，比如 `Animal` 类。

- **接口**：
  - 适用于**不同类之间的功能扩展**，如 `IFlyable` 可以应用于 `Bird` 和 `Airplane`。
  - 适合定义**行为能力**，比如 `IDisposable`、`IComparable`。


如果类之间是 **“是一种”（is-a）关系**，如 `Dog : Animal`，用**抽象类**；  
如果类之间是 **“能做什么”（can-do）关系**，如 `Bird : IFlyable`，用**接口**。

C#_接口和抽象类

C#_封装，继承，多态，抽象

# 概念
* 装箱：`值转引用`，把值类型用引用类型存储，栈内存上的数据会迁移到堆内存中，并返回一个对该对象的引用。
* 拆箱：`引用转值`，把引用类型存储的值还原为值类型，堆内存会迁移到栈，可能还会进行类型转换。
> 在不确定类型时使用装箱拆箱，可以方便我们进行参数的存储和传递



# 装箱拆箱可能带来的性能问题
* 装箱需要在堆上分配内存，并且要拷贝数据。
* 拆箱需要从堆中提取数据，并进行类型转换。
* GC 压力增加，因为装箱产生的对象需要由 GC 管理。

# 如何避免装箱拆箱
* 使用泛型，避免object作为参数或者集合存储类型
* 在不确定类型的时候，使用`is`或`as`进行安全的类型判断，再进行转换
* 自定义结构体的ToString（）也可能导致装箱，C#中自定义结构体没有重写ToString虚方法的话，就会导致装箱

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();
    }
}
```