C#嵌套类 内部类

嵌套类

Nesting Classes

类都有成员，而类的成员是另一个用户定义类型是完全可能的。比如，Button类可以有许多Location类型的成员，而Location类又包含许多Point类型的成员。Point也可以包含许多int类型的成员。

偶尔，被包含的类可以就是为其外层类服务而存在的，因此它不必向外界暴露。（说得简单点儿， 被包含类只是一个辅助类。）可以在外层类的定义中定义辅助类。这种被包含的内部类我们称之为嵌套类（nested class），而包含它的类我们直接称为外层类（outer class）。

嵌套类的好处是可以对外层类的所有成员进行访问。嵌套类的方法可以访问外层类的私有成员。

提示：而且，嵌套类可以对其他所有类隐藏，即它是外层类的私有成员。

还要说明，公共的嵌套类可以在外层类的作用域内访问。如果Outer是一个外层类，而Nested是（公共的）内部类，可以称Nested为Outer.Nested，其中外层类就或多或少地成为一种名字空间或作用域了。

提示：Java程序员注意了：嵌套类略等价于Java的静态内部类，但C#中不存在Java非静态内部类的等价物。

示例5-5在Fraction中添加了嵌套类FractionArtist。该类的作用是在控制台画出分数。本示例中绘制是用一对WriteLine()语句代替的。

示例5-5：使用嵌套类

#region Using directives

using System;

using System.Collections.Generic;

using System.Text;

示例5-5：使用嵌套类（续例）

#endregion

namespace NestedClasses

{

   public class Fraction

   {

      private int numerator;

      private int denominator;

      public Fraction( int numerator, int denominator )

      {

         this.numerator = numerator;

         this.denominator = denominator;

      }

      public override string ToString()

      {

         return String.Format( "{0}/{1}",

             numerator, denominator );

      }

      internal class FractionArtist

      {

         public void Draw( Fraction f )

         {

            Console.WriteLine( "Drawing the numerator: {0}",

               f.numerator );

            Console.WriteLine( "Drawing the denominator: {0}",

               f.denominator );

         }

      }

   }

   public class Tester

   {

      static void Main()

      {

         Fraction f1 = new Fraction( 3, 4 );

         Console.WriteLine( "f1: {0}", f1.ToString() );

         Fraction.FractionArtist fa = new Fraction.FractionArtist();

         fa.Draw( f1 );

      }

   }

}

嵌套类用黑体显示。FractionArtist类只有一个成员：Draw()方法。更有趣的是，Draw()可以访问私有数据成员f.numerator和f.denominator，如果不是嵌套类是根本不可能的。

注意在Main()中，要声明此嵌套类的一个实例，必须指定外层类的类型名：

Fraction.FractionArtist fa = new Fraction.FractionArtist();

FractionArtist的作用域限于Fraction类中。

 出自：http://blog.csdn.net/mydriverc/archive/2008/03/01/2137884.aspx

 嵌套类（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");

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/mydriverc/archive/2008/03/01/2137884.aspx

转载于:https://www.cnblogs.com/window5549-accp/archive/2012/08/06/2624931.html