Quais são os modificadores de acesso em C#?

Em C# existem os seguintes modificadores de acesso:

1. public: O acesso não é restrito. Os membros marcados como public são acessíveis de qualquer lugar onde o seu tipo contenedor seja acessível.
2. private: O acesso é restrito ao seu tipo contenedor. Os membros marcados como private são acessíveis apenas a partir do código dentro da mesma classe ou estrutura.
3. protected: O acesso é restrito ao tipo que o contém ou aos tipos derivados desse tipo. Os membros marcados como protected são acessíveis dentro da sua classe e nas classes derivadas.
4. internal: O acesso é restrito à compilação atual (.dll ou .exe). Os membros marcados como internal são acessíveis de qualquer lugar dentro da mesma compilação.
5. protected internal: O acesso é restrito à compilação atual ou aos tipos derivados do tipo que o contém em outras compilations. É uma combinação de protected e internal.
6. private protected: O acesso é restrito ao tipo que o contém ou aos tipos derivados desse tipo apenas na mesma compilação. É uma combinação de private e protected.

// Exemplo de uso de modificadores de acesso
public class MyClass
{
    public int PublicField;        // Acessível de qualquer lugar
    private int PrivateField;      // Acessível apenas dentro de MyClass
    protected int ProtectedField;  // Acessível dentro de MyClass e em classes derivadas
    internal int InternalField;    // Acessível dentro da compilação atual
    protected internal int ProtectedInternalField; // Acessível dentro da compilação atual OU em classes derivadas
    private protected int PrivateProtectedField; // Acessível dentro de MyClass OU em classes derivadas nesta mesma compilação

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

public class DerivedClass : MyClass
{
    void DerivedMethod()
    {
        ProtectedField = 20; // OK
        // PrivateField = 30; // Erro - campo privado não acessível na herança
        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; // Erro
        // mc.ProtectedField = 5; // Erro
        // mc.PrivateProtectedField = 6; // Erro
    }
}