Milyen hozzáférési módosítók vannak C#-ban?

C# nyelvben a következő hozzáférési módosítók léteznek:

1. public: A hozzáférés nem korlátozott. A public-ként megjelölt tagok bárhonnan elérhetők, ahol a tartalmazó típus elérhető.
2. private: A hozzáférés a tartalmazó típusra korlátozódik. A private-ként megjelölt tagok csak ugyanabban a osztályban vagy struktúrában lévő kódból érhetők el.
3. protected: A hozzáférés a tartalmazó típusra vagy annak leszármazott típusaira korlátozódik. A protected-ként megjelölt tagok az osztályon belül és a leszármazott osztályokban érhetők el.
4. internal: A hozzáférés a jelenlegi összeszerelésre (.dll vagy .exe) korlátozódik. Az internal-ként megjelölt tagok bárhonnan elérhetők ugyanabban az összeszerelésben.
5. protected internal: A hozzáférés a jelenlegi összeszerelésre vagy a tartalmazó típusból származó típusokra korlátozódik más összeszerelésekben. Ez a protected és internal kombinációja.
6. private protected: A hozzáférés a tartalmazó típusra vagy annak leszármazott típusaira korlátozódik csak ugyanabban az összeszerelésben. Ez a private és protected kombinációja.

// Példa a hozzáférési módosítók használatára
public class MyClass
{
    public int PublicField;        // Bárhonnan elérhető
    private int PrivateField;      // Csak a MyClass belsejéből elérhető
    protected int ProtectedField;  // A MyClass és leszármazott osztályokban elérhető
    internal int InternalField;    // A jelenlegi összeszerelésen belül elérhető
    protected internal int ProtectedInternalField; // A jelenlegi összeszerelésen belül vagy leszármazott osztályokban elérhető
    private protected int PrivateProtectedField; // A MyClass vagy ugyanabban az összeszerelésben lévő leszármazott osztályokban elérhető

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

public class DerivedClass : MyClass
{
    void DerivedMethod()
    {
        ProtectedField = 20; // OK
        // PrivateField = 30; // Hiba - privát mező nem elérhető öröklődésben
        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; // Hiba
        // mc.ProtectedField = 5; // Hiba
        // mc.PrivateProtectedField = 6; // Hiba
    }
}