最近在看java一方面的书籍，看到一个很奇怪的问题，java类中还可以再定义一个类，这种结构非常特殊！后来才发现我知识浅薄了，原来C#中也有内部类，之前都一直没有注意过这个语法结构！
使用内部类有这样几个好处:
（1）抽象外部类的某一状态下的行为，隐藏实现，通过修改该内的访问修饰符，可以设置仅有外部类可以访问该类
（2）扩展了命名空间，可以将外部类的类名作为内部类的一个命名空间(这里只是相当于，但不是真正的命名空间)
（3）内部类可以当作外部类的一个扩展，可以活的更好的封装。
上面的这些特点胡乱的总结了一下，可能有些词不达意，下面有些具体例子:
1.内部类的定义:
嵌套类：在一个类中定义另外一个类，主要分为静态嵌套类和非静态嵌套类(又称之为"内部类")
内部类的定义结构:(1)在一个类中直接定义类(2)在一个方法中定义类(3)匿名内部类
2.外部类访问内部类
1 namespace GameStatistical.Test.InnerClass
2 {
3 public class Person
4 {
5 public class Student
6 {
7 public static int age;
8 internal static int height;
9 private static string sex;
10
11 public virtual void Show()
12 {
13 Console.WriteLine("年龄:"+age);
14 Console.WriteLine("身高:"+height);
15 }
16
17 internal void Display()
18 {
19 Console.WriteLine("internal");
20 Console.WriteLine("年龄:" + age);
21 Console.WriteLine("身高:" + height);
22 }
23 }
24
25
26 public void Show()
27 {
28 Student.age = 21;
29 Student.height = 75;
30 Student student = new Student();
31 student.Show();
32 student.Display();
33 }
34 }
35 }
该段代码定义了一个外部类Person 和一个内部类Student， 其中内部类Student中使用了各种修饰符修饰的变量和方法，从上面的例子可以看出外部类只能够访问嵌套类中修饰符为public、internal的字段、方法、属性。
调用外部类的 Show（）方法运行得到如下结果:
3.内部类访问外部类
1 namespace GameStatistical.Test.InnerClass
2 {
3 public class Person1
4 {
5 private string name;
6
7 public string Name
8 {
9 get { return name; }
10 set { name = value; }
11 }
12 private string sex;
13
14 public string Sex
15 {
16 get { return sex; }
17 set { sex = value; }
18 }
19
20 public void Show1()
21 {
22 Console.WriteLine(this.name + "==>" + this.sex);
23 }
24
25 private static void Show2()
26 {
27 Console.WriteLine("===================>");
28 }
29
30 internal void Show3()
31 {
32 Console.WriteLine(this.name + "==>" + this.sex);
33 }
34
35
36
37 public class Student
38 {
39 public void SetPer(string name, string sex)
40 {
41 Person1 p = new Person1();
42 p.name = name;
43 p.sex = sex;
44
45 p.Show3();
46 p.Show1();
47 }
48
49 }
50 }
51 }
这段代码同样定义了一个外部类Person1 和一个内部类Student,内部类中的SetPer（）调用了外部类中的方法，写这段代码我们可以发现 嵌套类可以访问外部类的方法、属性、字段而不受访问修饰符的限制
4.内部类的继承
1 namespace GameStatistical.Test.InnerClass
2 {
3 public class Person
4 {
5 public class Student
6 {
7 public static int age;
8 internal static int height;
9 private static string sex;
10
11 public virtual void Show()
12 {
13 Console.WriteLine("年龄:"+age);
14 Console.WriteLine("身高:"+height);
15 }
16
17 internal void Display()
18 {
19 Console.WriteLine("internal");
20 Console.WriteLine("年龄:" + age);
21 Console.WriteLine("身高:" + height);
22 }
23 }
24
25
26 public void Show()
27 {
28 Student.age = 21;
29 Student.height = 75;
30 Student student = new Student();
31 student.Show();
32 student.Display();
33 }
34 }
35 }
内部类继承，上面的内部类定义了父类，其中public virtual void Show() 使用virtual 修饰，可以用于子类重写这个方法，看内部类继承子类是否能够重写这个方法。
1 namespace GameStatistical.Test.InnerClass
2 {
3 public class SubPerson:Person
4 {
5 public class SubStudent : Student
6 {
7 public override void Show()
8 {
9 base.Show();
10 }
11 }
12 }
13 }
上面的代码重写了Show() 这个方法，说明内部类的继承可以通过
5.反射内部类
对于这段代码，是从其他网站看到的，反射内部类我们不能直接通过 "." 操作符直接来操作，而是通过 "+" 操作符。前面也提到过内部类也是一种有效的管理命名空间的方法，这里也是普通类和内部类的一点区别
反射内部类
Activator.CreateInstance("GameStatistical.Test.InnerClass", "GameStatistical.Test.InnerClass.ReflectionPerson+Student");
反射普通类
Activator.CreateInstance("GameStatistical.Test.InnerClass", "GameStatistical.Test.InnerClass.ReflectionPerson.Student");
在实际操作中，内部类好像使用的比较少，这里也只是非常简单的介绍，作为一个知识点总结起来。
在《Java编程思想》中花了一章的篇幅介绍，内部类的相关特性。而在C#的书籍中很少有提交内部类的介绍。这篇文章，就简要介绍一下，C#中的内部类。
我们新建一个测试类文件，定义一个类：OuterClass。在其内部定义一个类：InnerClass1(暂且将其访问级别设置为public)。
来做几个简单测试，截图如下：
以上在InnerClass1中试图访问outerClass的实例变量失败！
内部类访问外部类的实例方法同样失败！
外部类也无法索引到内部类的实例变量（同样外部类也无法调用内部类的任何实例方法，即使方法是公有方法）。
这在预料之中：不管innerClass1定义在外部还是在OutClass内部，一个类的非静态方法和变量都只属于该类的对象。所以在一个类的外部，必须要通过类的实例来访问它的非静态成员。
可以看到内部类和外部类都可以顺利得访问各自的静态成员，这是因为静态成员是属于类本身的，只要能够访问类，就可以访问类的静态成员。上图中，由于是在内部类的外部引用内部类的静态成员，已经出了内部类的定义，所以需要内部类的类名来索引。而内部类访问外部类的静态成员时，由于内部类的定义在外部类中，并未出外部类，所以可以直接引用。
上图仅仅更改了一下，各个成员的访问级别。就出现了不同的结果。上图说明，外部类所有访问级别的静态成员对内部类始终可见。而内部类中静态成员的可见性，与普通类一样，受其定义时的访问级别控制。需要注意的是，其可见性与内部类【innerClass1】的访问级别无关。这是因为，从大的层面上来讲，innerClass1仍然是outerClass的成员之一，给它定义的访问级别是针对outerClass外部的，所以innerClass本身对outclass是一直可见的，而innerClass的内部成员却并不是都对outClass可见，因为outClass相对这些成员来说已经是innerClass的"外部"了。
如果将innerClass定义为public，那么它和普通的类并没有太大的区别，只是在创建它的时候需要“套”上外部类的名称罢了。这也是为什么可以将内部类视为外部类的成员的原因。示例如下：
其中，test（）为内部类的公有实例方法。
但是，如果将内部类的访问级别修改为private，就无法在外部索引它了。这不同于普通类(因为普通类不可以被定义为私有的)。但是还是有办法获得它的实例，我们可以在外部类中公有方法中，创建一个内部类的实例，并返回其引用：
虽然无法将实例对象的引用赋予一个该类型的变量（因为已经无法获得内部类的类型了），但是这并不影响去调用它的实例方法。因为outerClass的实例方法：GetInnerClassInstance（）拿到了innerclass1对象的引用。
控制这种“非法”访问的机制可以有几种：将内部类的构造器设为私有、或者严格设置内部类成员的访问级别。
这里只是粗略地讲解一下，C#中普通内部类的成员访问机制。这当然不是内部类的存在的意义。下面会继续探讨C#内部类的其他用处。
---------------------
作者：vinoYang
来源：CSDN
原文：https://blog.csdn.net/yanghua_kobe/article/details/6685222
版权声明：本文为博主原创文章，转载请附上博文链接！