C#嵌套类的使用方法及特性

嵌套类（Nested Class）是在类中定义的类。以下把拥有内嵌类的类称为外部类。根据《深
入理解嵌套类和内部类
》嵌套类分为静态嵌套类和非静态嵌套类，其中非静态嵌套类页被称为内部类。
嵌套类在UML中是composite的另外一种代码表示形式，表示耦合度更高，并且与外部类更加紧密。

一般类的 访问修饰符
可以定义为默认的internal
或者public，而内嵌类就有比较多的选择，可以是为protected、internal、public以及默认的private。

内嵌类与外部类的访问限制
嵌套类可以访问外部类的方法、属性、字段而不管访问修饰符的限制。如：

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
"
);