This chapter is from the book
This chapter is from the book
This chapter is from the book
3.5 Member Access
Declarations of members allow control over member access. The accessibility of a member is established by the declared accessibility (§3.5.1) of the member combined with the accessibility of the immediately containing type, if any.
When access to a particular member is allowed, the member is said to be accessible. Conversely, when access to a particular member is disallowed, the member is said to be inaccessible. Access to a member is permitted when the textual location in which the access takes place is included in the accessibility domain (§3.5.2) of the member.
3.5.1 Declared Accessibility
The declared accessibility of a member can be one of the following.
- Public, which is selected by including a public modifier in the member declaration. The intuitive meaning of public is "access not limited."
- Protected, which is selected by including a protected modifier in the member declaration. The intuitive meaning of protected is "access limited to the containing class or types derived from the containing class."
- Internal, which is selected by including an internal modifier in the member declaration. The intuitive meaning of internal is "access limited to this program."
- Protected internal (meaning protected or internal), which is selected by including both a protected and an internal modifier in the member declaration. The intuitive meaning of protected internal is "access limited to this program or types derived from the containing class."
- Private, which is selected by including a private modifier in the member declaration. The intuitive meaning of private is "access limited to the containing type."
Depending on the context in which a member declaration takes place, only certain types of declared accessibility are permitted. Furthermore, when a member declaration does not include any access modifiers, the context in which the declaration takes place determines the default declared accessibility.
- Namespaces implicitly have public declared accessibility. No access modifiers are allowed on namespace declarations.
- Types declared in compilation units or namespaces can have public or internal declared accessibility and default to internal declared accessibility.
- Class members can have any of the five kinds of declared accessibility and default to private declared accessibility. (Note that a type declared as a member of a class can have any of the five kinds of declared accessibility, but a type declared as a member of a namespace can have only public or internal declared accessibility.)
- Struct members can have public, internal, or private declared accessibility and default to private declared accessibility because structs are implicitly sealed. Struct members introduced in a struct (that is, not inherited by that struct) cannot have protected or protected internal declared accessibility. (Note that a type declared as a member of a struct can have public, internal, or private declared accessibility, but a type declared as a member of a namespace can have only public or internal declared accessibility.)
- Interface members implicitly have public declared accessibility. No access modifiers are allowed on interface member declarations.
- Enumeration members implicitly have public declared accessibility. No access modifiers are allowed on enumeration member declarations.
3.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 program text of a program is defined as all program text contained in all source files of the program, and the program text of a type is defined as all program text contained between the opening and closing { and } tokens in the class-body, struct-body, interface-body, or enum-body of the type (including, possibly, 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.
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.
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 may 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.
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.
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 (§3.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 (§3.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.
In the following example
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.
As described in §3.4, all members of a base class (except for instance constructors, destructors, 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. In the following example, the B class inherits the private member x from the A class.
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 } }
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.
3.5.3 Protected Access for Instance Members
When a protected instance member is accessed outside the program text of the class in which it is declared, and when a protected internal instance member is accessed outside the program text of the program in which it is declared, the access is required to take place through an instance of the derived class type in which the access occurs. In other words, let B be a base class that declares a protected instance member M, and let D be a class that derives from B. Within the class-body of D, access to M can take one of the following forms:
- An unqualified type-name or primary-expression of the form M
- A primary-expression of the form E.M, provided the type of E is D or a class derived from D
- A primary-expression of the form base.M
In addition to these forms of access, a derived class can access a protected instance constructor of a base class in a constructor-initializer (§10.10.1).
In the following example, within A, it is possible to access x through instances of both A and B because in either case the access takes place through an instance of A or a class derived from A.
public class A
{
protected int x;
static void F(A a, B b) {
a.x = 1; // Ok
b.x = 1; // Ok
}
}
public class B: A
{
static void F(A a, B b) {
a.x = 1; // Error, must access through instance of B
b.x = 1; // Ok
}
}
However, within B, it is not possible to access x through an instance of A because A does not derive from B.
3.5.4 Accessibility Constraints
Several constructs in the C# language require a type to be at least as accessible as a member or another type. A type T is said to be at least as accessible as a member or type M if the accessibility domain of T is a superset of the accessibility domain of M. In other words, T is at least as accessible as M if T is accessible in all contexts in which M is accessible.
The following accessibility constraints exist.
- The direct base class of a class type must be at least as accessible as the class type itself.
- The explicit base interfaces of an interface type must be at least as accessible as the interface type itself.
- The return type and parameter types of a delegate type must be at least as accessible as the delegate type itself.
- The type of a constant must be at least as accessible as the constant itself.
- The type of a field must be at least as accessible as the field itself.
- The return type and parameter types of a method must be at least as accessible as the method itself.
- The type of a property must be at least as accessible as the property itself.
- The type of an event must be at least as accessible as the event itself.
- The type and parameter types of an indexer must be at least as accessible as the indexer itself.
- The return type and parameter types of an operator must be at least as accessible as the operator itself.
- The parameter types of an instance constructor must be at least as accessible as the instance constructor itself.
In the following example, the B class results in a compile-time error because A is not at least as accessible as B.
class A {...}
public class B: A {...}
Likewise, in the following example, the H method in B results in a compile-time error because the return type A is not at least as accessible as the method.
class A {...}
public class B
{
A F() {...}
internal A G() {...}
public A H() {...}
}