2.8 Access Modifiers

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 later in this chapter) and interface members (see Section 2.10 later in this chapter).

internal

The type or type member in assembly A is accessible only from within A. This is the default accessibility for nonnested types, so it may be omitted.

private

The type member in type T is accessible only from within T. This is the default accessibility for class and struct members, so it may be omitted.

protected

The type member in class C is accessible only from within C or from within a class that derives from C.

protected internal

The type member in class C and assembly A is accessible only from within C, from within a class that derives from C, or from within A. Note that C# has no concept of protected and internal, in which a type member in class C and assembly A is accessible only from within C or from within a class that derives from C and is within A.

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
  }
}

2.8.1 Restrictions on Access Modifiers

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.