编辑“︁C Sharp 嵌套类型”︁（章节）

= C#嵌套类型 =

'''嵌套类型'''（Nested Types）是C#中的一个高级类特性，它允许在一个类或结构体内部定义另一个类或结构体。嵌套类型可以访问外部类的私有成员，同时也能控制自身的可见性。这一特性在封装相关功能、实现设计模式（如工厂模式）或构建复杂数据结构时非常有用。

== 基本概念 ==

嵌套类型是指定义在另一个类或结构体内部的类型。根据访问修饰符的不同，嵌套类型可以具有不同的作用域：

* '''私有嵌套类型'''（默认）：仅在包含它的外部类中可见。
* '''公共嵌套类型'''：可以被外部代码访问。
* '''受保护或内部嵌套类型'''：遵循常规的访问规则。

嵌套类型的典型用途包括：
* 实现仅对外部类有意义的辅助类
* 隐藏实现细节
* 创建特定于上下文的枚举或结构

== 语法示例 ==

以下是一个基本的嵌套类示例：

<syntaxhighlight lang="csharp">
public class OuterClass
{
    private int outerValue = 10;

    // 嵌套类
    public class NestedClass
    {
        public void DisplayOuterValue(OuterClass outer)
        {
            // 可以访问外部类的私有成员
            Console.WriteLine($"Outer value: {outer.outerValue}");
        }
    }
}

class Program
{
    static void Main()
    {
        OuterClass outer = new OuterClass();
        OuterClass.NestedClass nested = new OuterClass.NestedClass();
        nested.DisplayOuterValue(outer); // 输出: Outer value: 10
    }
}
</syntaxhighlight>

== 访问修饰符与可见性 ==

嵌套类型的可见性由访问修饰符控制：

{| class="wikitable"
|+ 嵌套类型访问修饰符
! 修饰符 !! 描述
|-
| <code>private</code> || （默认）仅在包含类中可见
|-
| <code>public</code> || 任何地方可见
|-
| <code>protected</code> || 包含类及其派生类可见
|-
| <code>internal</code> || 同一程序集中可见
|-
| <code>protected internal</code> || 同一程序集或派生类中可见
|}

== 实际应用案例 ==

=== 1. 实现工厂模式 ===

嵌套类常用于实现工厂模式，其中工厂类是外部类，而产品类是嵌套类：

<syntaxhighlight lang="csharp">
public class VehicleFactory
{
    private VehicleFactory() {} // 私有构造函数

    // 嵌套类表示产品
    public class Car
    {
        public string Model { get; set; }
    }

    public class Truck
    {
        public int LoadCapacity { get; set; }
    }

    // 工厂方法
    public static Car CreateCar(string model)
    {
        return new Car { Model = model };
    }

    public static Truck CreateTruck(int capacity)
    {
        return new Truck { LoadCapacity = capacity };
    }
}

// 使用
var myCar = VehicleFactory.CreateCar("Sedan");
var myTruck = VehicleFactory.CreateTruck(5000);
</syntaxhighlight>

=== 2. 树形数据结构 ===

嵌套类非常适合表示树形结构的节点：

<syntaxhighlight lang="csharp">
public class Tree<T>
{
    private Node root;

    // 嵌套类表示树节点
    private class Node
    {
        public T Data { get; set; }
        public Node Left { get; set; }
        public Node Right { get; set; }

        public Node(T data)
        {
            Data = data;
        }
    }

    public void Add(T value)
    {
        // 实现添加逻辑...
    }
}
</syntaxhighlight>

== 嵌套类型与泛型 ==

嵌套类型可以使用外部类的泛型参数：

<syntaxhighlight lang="csharp">
public class Outer<T>
{
    public class Nested<U>
    {
        public T OuterGeneric { get; set; }
        public U NestedGeneric { get; set; }
    }
}

// 使用
var nested = new Outer<int>.Nested<string>();
nested.OuterGeneric = 42;
nested.NestedGeneric = "Hello";
</syntaxhighlight>

== 嵌套结构体 ==

除了类，也可以嵌套结构体：

<syntaxhighlight lang="csharp">
public class Graph
{
    public struct Point
    {
        public int X { get; set; }
        public int Y { get; set; }
    }

    public void DrawLine(Point p1, Point p2)
    {
        // 绘制逻辑...
    }
}
</syntaxhighlight>

== 关系图 ==

以下mermaid图展示了嵌套类型与外部类的关系：

<mermaid>
classDiagram
    class OuterClass {
        -outerField
        +NestedClass
    }
    
    class NestedClass {
        +Method()
    }
    
    OuterClass --> NestedClass : 包含
</mermaid>

== 注意事项 ==

1. '''命名空间冲突'''：嵌套类型不会与同名顶级类型冲突
2. '''静态成员'''：嵌套类型可以包含静态成员
3. '''继承'''：嵌套类型可以继承其他类或实现接口
4. '''性能'''：嵌套类型不会带来额外性能开销
5. '''可读性'''：过度使用嵌套类型可能降低代码可读性

== 高级用法：嵌套枚举 ==

嵌套枚举有助于将相关常量组织在一起：

<syntaxhighlight lang="csharp">
public class NetworkManager
{
    public enum ConnectionStatus
    {
        Disconnected,
        Connecting,
        Connected
    }

    public ConnectionStatus Status { get; private set; }

    public void Connect()
    {
        Status = ConnectionStatus.Connecting;
        // 连接逻辑...
        Status = ConnectionStatus.Connected;
    }
}
</syntaxhighlight>

== 数学表示 ==

从数学角度看，嵌套类型可以表示为：

<math>
\text{Outer} \times \text{Nested} \rightarrow \text{Composite}
</math>

其中外部类与嵌套类共同构成一个复合结构。

== 总结 ==

C#嵌套类型是一个强大的封装工具，它：
* 提高了代码的组织性和封装性
* 允许更细粒度的访问控制
* 有助于实现特定设计模式
* 减少命名空间污染

合理使用嵌套类型可以创建更清晰、更模块化的代码结构，但应注意不要过度使用而导致代码难以理解。

[[Category:编程语言]]
[[Category:C Sharp]]
[[Category:C Sharp 高级类特性]]