ECMA-334: 10.5.2 Accessibility domains

Microsoft .NET Framework, ASP.NET, Visual C# (CSharp, C Sharp, C-Sharp) Developer Training, Visual Studio

C# Language Specification

10. Basic concepts 10.5 Member access 10.5.1 Declared accessibility 10.5.2 Accessibility domains 10.5.3 Protected access for instance members 10.5.4 Accessibility constraints

© 2006 ECMA International

10.5.2 Accessibility domains

The accessibility domain of a member consists of the (possibly disjoint) sections of program text in which access to the member is permitted. For purposes of defining the accessibility domain of a member, a member is said to be top-level if it is not declared within a type, and a member is said to be nested if it is declared within another type. Furthermore, the text of a program is defined as all source text contained in all source files of that program, and the source text of a type is defined as all source text contained between the opening and closing "{" and "}" tokens in the class-body, struct-body, interface-body, or enum-body of all declarations for the type (including, possibly, multiple partial declarations and all types that are nested within the type).

The accessibility domain of a predefined type (such as object, int, or double) is unlimited.

The accessibility domain of a top-level type T that is declared in a program P is defined as follows:

• If the declared accessibility of T is public, the accessibility domain of T is the program text of P and any program that references P.

• If the declared accessibility of T is internal, the accessibility domain of T is the program text of P. [Note: From these definitions, it follows that the accessibility domain of a top-level type is always at least the program text of the program in which that type is declared. end note] The accessibility domain of a nested member M declared in a type T within a program P, is defined as follows (noting that M itself might possibly be a type):

• If the declared accessibility of M is public, the accessibility domain of M is the accessibility domain of T.

• If the declared accessibility of M is protected internal, let D be the union of the program text of P and the program text of any type derived from T, which is declared outside P. The accessibility domain of M is the intersection of the accessibility domain of T with D.

• If the declared accessibility of M is protected, let D be the union of the program text of T and the program text of any type derived from T. The accessibility domain of M is the intersection of the accessibility domain of T with D.

• If the declared accessibility of M is internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P.

• If the declared accessibility of M is private, the accessibility domain of M is the program text of T.

[Note: From these definitions, it follows that the accessibility domain of a nested member is always at least the program text of the type in which the member is declared. Furthermore, it follows that the accessibility domain of a member is never more inclusive than the accessibility domain of the type in which the member is declared. end note]

[Note: In intuitive terms, when a type or member M is accessed, the following steps are evaluated to ensure that the access is permitted:

• First, if M is declared within a type (as opposed to a compilation unit or a namespace), a compile-time error occurs if that type is not accessible.

• Then, if M is public, the access is permitted.

• Otherwise, if M is protected internal, the access is permitted if it occurs within the program in which M is declared, or if it occurs within a class derived from the class in which M is declared and takes place through the derived class type (§10.5.3).

• Otherwise, if M is protected, the access is permitted if it occurs within the class in which M is declared, or if it occurs within a class derived from the class in which M is declared and takes place through the derived class type (§10.5.3).

• Otherwise, if M is internal, the access is permitted if it occurs within the program in which M is declared.

• Otherwise, if M is private, the access is permitted if it occurs within the type in which M is declared.

• Otherwise, the type or member is inaccessible, and a compile-time error occurs.

end note]

[Example: In the following code

public class A
{
  public static int X;
  internal static int Y;
  private static int Z;
}
internal class B
{
  public static int X;
  internal static int Y;
  private static int Z;
  public class C
  {
    public static int X;
    internal static int Y;
    private static int Z;
  }
  private class D
  {
    public static int X;
    internal static int Y;
    private static int Z;
  }
}

the classes and members have the following accessibility domains:

• The accessibility domain of A and A.X is unlimited.

• The accessibility domain of A.Y, B, B.X, B.Y, B.C, B.C.X, and B.C.Y is the program text of the containing program.

• The accessibility domain of A.Z is the program text of A.

• The accessibility domain of B.Z and B.D is the program text of B, including the program text of B.C and B.D.

• The accessibility domain of B.C.Z is the program text of B.C.

• The accessibility domain of B.D.X and B.D.Y is the program text of B, including the program text of B.C and B.D.

• The accessibility domain of B.D.Z is the program text of B.D.

As the example illustrates, the accessibility domain of a member is never larger than that of a containing type. For example, even though all X members have public declared accessibility, all but A.X have accessibility domains that are constrained by a containing type. end example]

As described in §10.4, all members of a base class, except for instance constructors, finalizers, and static constructors are inherited by derived types. This includes even private members of a base class. However, the accessibility domain of a private member includes only the program text of the type in which the member is declared. [Example: In the following code

class A
{
  int x;
  static void F(B b)
  {
    b.x = 1; // Ok
  }
}
class B: A
{
  static void F(B b)
  {
    b.x = 1; // Error, x not accessible
  }
}

the B class inherits the private member x from the A class. Because the member is private, it is only accessible within the class-body of A. Thus, the access to b.x succeeds in the A.F method, but fails in the B.F method. end example]