Nested Types (C# Programming Guide)

A type defined within a class or struct is called a nested type. For example:

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

Regardless of whether the outer type is a class or a struct, nested types default to private; they are accessible only from their containing type. In the previous example, the Nested class is inaccessible to external types.

You can also specify an access modifier to define the accessibility of a nested type, as follows:

The following example makes the Nested class public:

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

The nested, or inner, type can access the containing, or outer, type. To access the containing type, pass it as an argument to the constructor of the nested type. For example:

public class Container
{
    public class Nested
    {
        private Container parent;

        public Nested()
        {
        }
        public Nested(Container parent)
        {
            this.parent = parent;
        }
    }
}

A nested type has access to all of the members that are accessible to its containing type. It can access private and protected members of the containing type, including any inherited protected members.

In the previous declaration, the full name of class Nested is Container.Nested. This is the name used to create a new instance of the nested class, as follows:

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

See Also

C# Programming Guide
Classes and Structs
Access Modifiers
Constructors