C#类的嵌套-阿里云开发者社区

C#类的嵌套

2017-11-07 1045

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介：

C# 类的嵌套

(2009-07-17 20:56:22)

转载

嵌套类（ 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 类在名称为 InsideClass 的 Assembly 中。

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

本文转自gauyanm 51CTO博客，原文链接：http://blog.51cto.com/gauyanm/305110，如需转载请自行联系原作者

C#类的嵌套

热门文章

最新文章

相关电子书

相关实验场景