正文
Nested Class（嵌套类）
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
在类、结构或接口中定义的类型称为嵌套类型。 例如
public class Container
{
class Nested
{
Nested() { }
}
}
不论外部类型是类、接口还是构造，嵌套类型均默认为 private；仅可从其包含类型中进行访问。 在上一个示例中，
Nested
类无法访问外部类型。
还可指定访问修饰符来定义嵌套类型的可访问性，如下所示：
-
“类”的嵌套类型可以是 public、protected、internal、protected internal、private 或 private protected。
但是，在密封类中定义
protected、protected internal或private protected嵌套类将产生编译器警告 CS0628“封闭类汇中声明了新的受保护成员”。另请注意，使嵌套类型在外部可见违反了代码质量规则 CA1034“嵌套类型不应是可见的”。
-
构造的嵌套类型可以是 public、internal 或 private。
以下示例使
Nested
类为 public：
public class Container
{
public class Nested
{
Nested() { }
}
}
内嵌类与外部类的访问限制
嵌套类可以访问外部类的方法、属性、字段而不管访问修饰符的限制。如：
public class A
{
private static int _AInt;
private int _instanceInt;
private static void AMethod()
{
Console.WriteLine(_AInt);
}
public void SayIt()
{
NestedA.Method( this );
}
/* 嵌套类 定义 */
private class NestedA
{
public static void Method(A a)
{
// 静态成员
_AInt = 100 ;
AMethod();
//实例 成员
a._instanceInt = 10 ;
a.SayIt();
}
}
}
但是外部类只能够访问修饰符为public、internal嵌套类的字段、方法、属性。示例如下：
public class A
{
public static void AMethod()
{
// 成功
NestedA.StaticMethod();
// 编译报错
NestedA._Int = 100 ; NestedA ins = new NestedA();
// 成功
ins.Method();
// 编译报错
ins._instanceInt = 100 ;
}
/* 嵌套类 定义 */
private class NestedA
{
private static int _Int;
private int _instanceInt;
public static void StaticMethod() { }
public void Method(){}
}
嵌套类访问外部类实例的方法、字段、属性时候。一般在采取构造函数输入外部类。如下：
public class A
{
private int _a; /* 嵌套类 定义 */
private class NestedA
{
public NestedA(A a)
{
a._a = 9 ;
}
}
}
继承
继承类，也就是继承类外部类的类，只能使用父类中嵌套类的public或者internal(同一个程序集合)方法。但是继承类可以再定义一个内嵌类并从继承父类中嵌套类。如：
public class A
{
/* 嵌套类 定义 */
protected class Nested
{
protected virtual void BaseNested_Method(){}
}
} public class C : A
{
/* 内嵌类 定义 */
protected class C_Nested:Nested
{
protected override void BaseNested_Method()
{
// 重写部分
}
}
}
因为C中A中继承，因此C_Nested可以继承Nested类，从而获取重写父嵌套类的机会。但是Nested必须是可继承类及可访问的（非private 、sealed、static）。
嵌套类可以随意访问外部类的任何数据属性，而外部类访问嵌套类就只能遵守访问修饰符。从这个角度看，嵌套类是外部类的补充，通过嵌套类可以获取更好的封装性，增加外部类的可维护性和可读性。
从程序结构看，嵌套类在逻辑上更加接近使用类。可以更有效地表示类与类之间的紧密程度。为类管理提供除命名空间外的另一种方法。
懒加载
嵌套类的静态构造函数不会随着外部类的触发而初始化。因此可以有效地避免创建时候初始化时间，当需要使用内嵌类的时候，嵌套类才开始初始化才开始初始化。
public class Outside
{
static Outside()
{
Console.WriteLine( " Outside Inilizlized " );
}
public void SayIt()
{
Nested.Run();
}
private class Nested
{
static Nested()
{
Console.WriteLine( " Nested initilized " );
} public static void Run()
{
Console.WriteLine( " Nested Run " );
}
}
}
执行结果
Outside o = new Outside(); // 打印"Outside Inilizlized"
Console.ReadLine();
o.SayIt(); // 首先打印"Nested initilized" 再打印 "Nested Run"
Console.ReadLine();
一般应用这个特性会在一些C#单例模式中找到，而这种模式可以被称为Fully lazy singleton模式。下面是简单的演示代码（Singleton模式可以在这里有更加详细的解释）：
public class Singleton
{
public static Singleton Instance
{
get
{
return Nested.instance;
}
}
private class Nested
{
public readonly static Singleton instance = new Singleton();
}
}
反射
反射内嵌类需要使用"+"而不是我们常使用的"." 。如A类在Assembly名称为InsideClass中。
namespace InsideClass
{
public class A
{
public class Nested
{
protected void BaseNested_Method()
{
}
}
}
}
执行
// 成功
object o1 = System.Activator.CreateInstance( " InsideClass " , " InsideClass.A+Nested " );
// 失败 抛出System.TypeLoadException 异常
object o2 = System.Activator.CreateInstance( " InsideClass " , " InsideClass.A.Nested " );
原文链接：https://blog.csdn.net/hemeinvyiqiluoben/article/details/47276271
