C#嵌套类型

1.什么是嵌套类型:在类和结构内部定义的类型称为嵌套类型，例如

1 class Container
2 {
3     class Nested
4     {
5         Nested() { }
6     }
7 }

2.不管外部类型是结构还是类。嵌套类型修饰符默认为private，可以设置为其他的修饰符，嵌套类型对外部类型是不可访问的 ，可以设置为public。

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

　3.嵌套类型（或内部类型）可访问包含类型（或外部类型）。若要访问包含类型，请将其作为构造函数传递给嵌套类型,不受外部类的修饰符限制例如：

 public class A
        {
            private int _a;
           
            /*嵌套类 定义*/
            private class NestedA
            {
                public NestedA(A a)
                {
                    a._a = 9;
                }              
            }
        }

View Code

 

public class Container
{

public class Nested
{
private  Container  m_parent;
public Nested()
{
}
public Nested(Container parent)
{
m_parent=parent;
}
}
}

View Code

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();
            }
        }
    }

View Code

但是外部类只能够访问修饰符为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(){}
        }
    }

View Code

 继承：

   继承类，也就是继承类外部类的类，只能使用父类中嵌套类的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()
                {
                    //重写部分
        }
       }
 }

View Code

   因为C中A中继承，因此C_Nested可以继承Nested类，从而获取重写父嵌套类的机会。但是Nested必须是可继承类及可访问的（非private 、sealed、static）。

         嵌套类可以随意外部类的任何数据属性，而外部类访问嵌套类就只能遵守访问修饰符。从这个角度看，嵌套类是外部类的补充，通过嵌套类可以获取更好的封装性，增加外部类的可维护性和可读性。    

 

嵌套类型可访问包含类型的私有成员和受保护的成员（包括所有继承的私有成员或受保护的成员）。

在前面的声明中，类 Nested 的完整名称为 Container.Nested。这是用来创建嵌套类的新实例的名称，如下所示：

Container.Nested nest = new Container.Nested();

转载于:https://www.cnblogs.com/jing187/p/4340349.html