To promote encapsulation, a type or type member may hide itself from other types or other assemblies, by adding one of the following five access modifiers to the declaration:
-
public The type or type member is fully accessible. This is the implicit accessibility for enum members (see Section 2.12) and interface members (see Section 2.10).
-
internal The type or type member in assembly
Ais accessible only from withinA. This is the default accessibility for nonnested types, so may be omitted.-
private The type member in type
Tis accessible only from withinT. This is the default accessibility for class and struct members, so it may be omitted.-
protected The type member in class
Cis accessible only from withinCor from within a class that derives fromC.-
protectedinternal The type member in class
Cand assemblyAis accessible only from withinC, from within a class that derives fromC, or from withinA. Note that C# has no concept ofprotectedandinternal, where a type member in classCand assemblyAis accessible only from withinCor from within a class that derives fromCand is withinA.
Note that a type member may be a nested type. Here is an example that uses access modifiers:
// Assembly1.dll
using System;
public class A {
private int x=5;
public void Foo( ) {Console.WriteLine (x);}
protected static void Goo( ) {}
protected internal class NestedType {}
}
internal class B {
private void Hoo ( ) {
A a1 = new A ( ); // ok
Console.WriteLine(a1.x); // error, A.x is private
A.NestedType n; // ok, A.NestedType is internal
A.Goo( ); // error, A's Goo is protected
}
}
// Assembly2.exe (references Assembly1.dll)
using System;
class C : A { // C defaults to internal
static void Main( ) { // Main defaults to private
A a1 = new A( ); // ok
a1.Foo( ); // ok
C.Goo( ); // ok, inherits A's protected static member
new A.NestedType( ); // ok, A.NestedType is protected
new B( ); // error, Assembly 1's B is internal
Console.WriteLine(x); // error, A's x is private
}
}A type or type member can’t declare
itself to be more accessible than any of the types it uses in its
declaration. For instance, a class can’t be
public if it derives from an internal class, or a
method can’t be protected if the type of one of its parameters
is internal to the assembly. The rationale behind this restriction is
that whatever is accessible to another type is actually usable by
that type.
In addition, access modifiers can’t be used when they conflict
with the purpose of inheritance modifiers. For example, a
virtual (or abstract) member
can’t be declared private, since it would
then be impossible to override. Similarly, a sealed class can’t
define new protected members, since there is no class that can
benefit from this accessibility.
Finally, to maintain the contract of a base class, a function member
with the override modifier must have the same
accessibility as the virtual member it overrides.