Nested Class（嵌套类）

在类、结构或接口中定义的类型称为嵌套类型。 例如

public class Container
{
    class Nested
    {
        Nested() { }
    }
}

不论外部类型是类、接口还是构造，嵌套类型均默认为 private；仅可从其包含类型中进行访问。 在上一个示例中，Nested 类无法访问外部类型。

还可指定访问修饰符来定义嵌套类型的可访问性，如下所示：

以下示例使 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

posted @ 2021-09-22 10:14  小林野夫  阅读(230)  评论(0)  编辑  收藏  举报
原文链接：https://www.cnblogs.com/cdaniu/