====== C# 系统关键词与修饰符 ======

在 C# 中，修饰符（Modifiers）用于定义类型和成员的访问级别、继承行为以及其他特性。合理使用修饰符是实现封装、多态和代码管理的基础。

===== 关键词速查表 =====

^ 关键词 ^ 含义 ^ 使用场景 ^ 为什么要使用 (核心价值) ^
| ''public'' | **公共的** | 需要对外完全暴露的类、属性或方法 | **开放接口**：方便外部模块调用，作为类的对外契约 |
| ''private'' | **私有的** | 仅在类内部使用的变量或辅助方法 | **封装/安全**：隐藏内部实现细节，防止外部随意修改数据 |
| ''protected''| **受保护的**| 允许子类访问，但不对外公开 | **继承扩展**：允许子类复用或修改父类逻辑，但不暴露给外界 |
| ''internal'' | **内部的** | 仅在当前项目(Assembly)内可访问 | **组件封装**：在同一个DLL内共享，但不对引用该DLL的项目公开 |
| ''static'' | **静态的** | 属于类本身，而非类的实例 | **全局/工具**：无需实例化即可使用，常用于工具类或全局配置 |
| ''sealed'' | **密封的** | 不能被继承的类，或不能被重写的方法 | **防篡改**：确保类的行为固定，防止子类破坏核心逻辑；微小的性能优化 |
| ''partial'' | **分部的** | 将一个类的代码拆分到多个文件中 | **代码管理**：解决单文件代码过长问题；配合代码生成器（如WinForms/WPF）使用 |
| ''abstract'' | **抽象的** | 只有定义没有实现的类或方法 | **强制规范**：定义一个模板，强制子类必须去实现具体逻辑 |
| ''virtual'' | **虚拟的** | 允许子类重写的方法 | **多态性**：提供默认实现，但允许子类根据需要修改行为 |
| ''override'' | **重写** | 子类重新实现父类的虚方法/抽象方法 | **多态性**：覆盖父类行为，实现子类特有的逻辑 |
| ''event'' | **事件** | 实现事件订阅 | 限制外部访问权限，只给订阅通知权限 |

===== 详细解析与案例 =====

==== 1. 访问修饰符 (public / private) ====

这是最基础的封装概念。

<code csharp>
public class User
{
    // public: 外部可以随意读取和修改（通常建议配合属性使用）
    public string NickName; 

    // private: 外部无法访问，只能在 User 类内部使用
    private string _password; 

    public void SetPassword(string pwd)
    {
        // 在类内部可以访问 private 变量
        _password = pwd; 
    }
}
</code>

==== 2. 密封与分部 (sealed / partial) ====

这是你提到的重点关键词。

**sealed (密封)**
用于防止类被继承，或者防止方法被进一步重写。

<code csharp>
// 这是一个最终版本，不允许其他人再继承修改它
public sealed class FinalLogic
{
    public void DoWork() { ... }
}

// 错误写法：编译器会报错
// class MyClass : FinalLogic { } 
</code>

**partial (分部)**
常用于多人协作或自动生成的代码。

**文件 1: Person.Part1.cs**
<code csharp>
public partial class Person
{
    public string Name { get; set; }
}
</code>

**文件 2: Person.Part2.cs**
<code csharp>
public partial class Person
{
    public void SayHello()
    {
        // 可以直接访问另一部分定义的 Name
        Console.WriteLine("Hello " + Name);
    }
}
</code>
*注：编译时，这两个部分会被合并成一个完整的 `Person` 类。*

==== 3. 多态与继承 (virtual / override / abstract) ====

这是面向对象编程的核心。

<code csharp>
// 父类
public class Animal
{
    // virtual: 允许子类重写这个方法
    public virtual void Speak()
    {
        Console.WriteLine("动物发出声音");
    }
}

// 子类
public class Dog : Animal
{
    // override: 重写父类的逻辑
    public override void Speak()
    {
        Console.WriteLine("汪汪汪");
    }
}

// 抽象类案例
public abstract class Shape
{
    // abstract: 我不知道怎么算面积，子类必须自己写
    public abstract double GetArea();
}
</code>

==== 4. 静态 (static) ====

静态成员属于类，不属于对象。

<code csharp>
public class Tools
{
    // 静态变量：所有实例共享一份
    public static double Pi = 3.14159;

    // 静态方法：直接通过 Tools.Add() 调用
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

// 调用方式
double area = Tools.Pi * 10 * 10; // 不需要 new Tools()
</code>


==== 5. Event (事件) 关键词 ====

在 C# 中，**event** 关键词用于在类或对象中声明事件。事件允许类或对象在发生某些特定情况时通知其他类或对象。这是一种基于 **发布-订阅 (Publish-Subscribe)** 模式的机制。

=== 1. 核心概念 ===

  * **发布者 (Publisher)**：定义事件并决定何时触发事件的类。
  * **订阅者 (Subscriber)**：监听事件并在事件触发时执行特定操作的类。
  * **委托 (Delegate)**：事件底层的类型安全函数指针，定义了事件处理程序的签名。

=== 2. 语法结构 ===

声明一个事件通常包含两个步骤：
  - 1. 定义委托（或者使用系统内置的 `EventHandler`）。
  - 2. 使用 `event` 关键词声明事件变量。

<code csharp>
public delegate void MyEventHandler(string message); // 1. 定义委托
public event MyEventHandler OnProcessCompleted;      // 2. 声明事件
</code>

=== 3. 实战案例 ===

以下是一个完整的控制台程序案例，模拟了一个视频编码器（发布者）和邮件服务（订阅者）。

== 案例代码 ==

<code csharp>
using System;

namespace EventDemo
{
    // 1. 定义包含事件数据的类 (可选，但推荐)
    public class VideoEventArgs : EventArgs
    {
        public string Title { get; set; }
    }

    // 2. 发布者：视频编码器
    public class VideoEncoder
    {
        // 声明事件：使用内置的 EventHandler<T> 泛型委托
        // 这里的 event 关键词是核心
        public event EventHandler<VideoEventArgs> VideoEncoded;

        public void Encode(string title)
        {
            Console.WriteLine($"正在编码视频: {title}...");
            System.Threading.Thread.Sleep(1000); // 模拟工作

            // 触发事件
            OnVideoEncoded(title);
        }

        // 按照约定，创建一个受保护的虚方法来触发事件
        protected virtual void OnVideoEncoded(string title)
        {
            // 检查是否有订阅者 (VideoEncoded != null)
            VideoEncoded?.Invoke(this, new VideoEventArgs { Title = title });
        }
    }

    // 3. 订阅者：邮件服务
    public class MailService
    {
        // 事件处理程序：签名必须与委托匹配
        public void OnVideoEncoded(object source, VideoEventArgs e)
        {
            Console.WriteLine($"邮件服务：发送邮件，视频 '{e.Title}' 编码完成。");
        }
    }

    // 4. 主程序
    class Program
    {
        static void Main(string[] args)
        {
            var video = new VideoEncoder(); // 发布者
            var mailService = new MailService(); // 订阅者

            // 订阅事件：使用 += 操作符
            video.VideoEncoded += mailService.OnVideoEncoded;

            video.Encode("复仇者联盟");
        }
    }
}
</code>

== 输出结果 ==

<code text>
正在编码视频: 复仇者联盟...
邮件服务：发送邮件，视频 '复仇者联盟' 编码完成。
</code>

=== 4. 关键点总结 ===

  * **封装性**：`event` 关键词为委托实例提供了一层封装。在类的外部，客户端只能使用 `+=` (订阅) 和 `-=` (取消订阅)，而不能直接使用 `=` 赋值（这会覆盖其他订阅者）或直接调用 `Invoke()`。
  * **空检查**：在触发事件前，务必检查事件是否为 `null`（即是否有订阅者），C# 6.0 以后推荐使用 `?.Invoke()`。
  * **命名规范**：事件通常命名为 `Name` 或 `OnName`，处理方法通常命名为 `OnName`。