¿Cuáles son los modificadores de acceso en C#?

En C# existen los siguientes modificadores de acceso:

1. public: El acceso no está restringido. Los miembros marcados como public son accesibles desde cualquier lugar donde esté accesible su tipo contenedor.
2. private: El acceso está restringido a su tipo contenedor. Los miembros marcados como private solo son accesibles desde el código dentro de la misma clase o estructura.
3. protected: El acceso está restringido al tipo que lo contiene o a los tipos derivados de ese tipo. Los miembros marcados como protected son accesibles dentro de su clase y en las clases derivadas.
4. internal: El acceso está restringido a la compilación actual (.dll o .exe). Los miembros marcados como internal son accesibles desde cualquier lugar dentro de la misma compilación.
5. protected internal: El acceso está restringido a la compilación actual o a los tipos derivados del tipo que lo contiene en otras compilaciones. Es una combinación de protected e internal.
6. private protected: El acceso está restringido al tipo que lo contiene o a los tipos derivados de ese tipo solo en la misma compilación. Es una combinación de private y protected.

// Ejemplo de uso de modificadores de acceso
public class MyClass
{
    public int PublicField;        // Accesible desde cualquier lugar
    private int PrivateField;      // Solo accesible dentro de MyClass
    protected int ProtectedField;  // Accesible dentro de MyClass y en clases derivadas
    internal int InternalField;    // Accesible dentro de la compilación actual
    protected internal int ProtectedInternalField; // Accesible dentro de la compilación actual O en clases derivadas
    private protected int PrivateProtectedField; // Accesible dentro de MyClass O en clases derivadas en esta misma compilación

    void MyMethod()
    {
        PrivateField = 10; // OK
    }
}

public class DerivedClass : MyClass
{
    void DerivedMethod()
    {
        ProtectedField = 20; // OK
        // PrivateField = 30; // Error - campo privado no accesible en la herencia
        ProtectedInternalField = 40; // OK
        PrivateProtectedField = 50; // OK
    }
}

public class AnotherClassInSameAssembly
{
    void AnotherMethod()
    {
        MyClass mc = new MyClass();
        mc.PublicField = 1; // OK
        mc.InternalField = 2; // OK
        mc.ProtectedInternalField = 3; // OK
        // mc.PrivateField = 4; // Error
        // mc.ProtectedField = 5; // Error
        // mc.PrivateProtectedField = 6; // Error
    }
}