Zugriffsmodifikatoren

Teil des Abschnitts Objektorientierte Programmierung der C#-Journey von Coddy — Lektion 31 von 70.

Zugriffsmodifikatoren steuern, wer Ihre Klassenmitglieder sehen und verwenden kann. Sie sind die Grundlage der Kapselung – eines der Kernprinzipien der OOP. Durch die Einschränkung des Zugriffs schützen Sie Ihre Daten und schaffen klare Grenzen in Ihrem Code.

C# bietet vier Haupt-Zugriffsmodifizierer:

public class BankAccount
{
    public string AccountHolder;      // Von überall zugänglich
    private decimal balance;          // Nur innerhalb dieser Klasse
    protected string accountType;     // Diese Klasse und abgeleitete Klassen
    internal int branchCode;          // Innerhalb derselben Assembly
}

Auf public Member kann von jedem Code aus zugegriffen werden.

Auf private Member kann nur innerhalb derselben Klasse zugegriffen werden – dies ist die restriktivste Zugriffsebene und der Standard für Klassen-Member.

protected ermöglicht den Zugriff von der Klasse selbst und jeder Klasse, die von ihr erbt.

internal beschränkt den Zugriff auf Code innerhalb derselben Assembly (Projekt).

Wenn kein Modifikator angegeben ist, sind Klassenmitglieder standardmäßig private:

class Example
{
    int secret;  // standardmäßig private
}

Die Wahl der richtigen Zugriffsebene bedeutet, nur das Notwendige offenzulegen. Beginnen Sie mit private und erhöhen Sie die Sichtbarkeit nur dann, wenn Sie einen klaren Grund dafür haben. Dies verhindert, dass anderer Code von Implementierungsdetails abhängt, die Sie später möglicherweise ändern möchten.

Aufgabe

Einfach

Lassen Sie uns ein sicheres Benutzerprofilsystem erstellen, das zeigt, wie Zugriffsmodifizierer sensible Daten schützen und gleichzeitig nur das Notwendige offenlegen. Sie werden eine Klasse erstellen, in der verschiedene Informationen unterschiedliche Sichtbarkeitsebenen haben, basierend darauf, wer darauf zugreifen können sollte.

Sie werden Ihren Code über drei Dateien organisieren:

UserProfile.cs: Erstellen Sie eine UserProfile-Klasse im Namespace Security, die Benutzerinformationen mit entsprechenden Zugriffsebenen verwaltet. Das Profil sollte Folgendes haben:
- Eine public Eigenschaft Username (string) - jeder kann den Benutzernamen sehen
- Ein private Feld password (string) - nur die Klasse selbst sollte darauf zugreifen
- Ein protected Feld email (string) - die Klasse und ihre Kindklassen können darauf zugreifen
- Ein internal Feld userId (int) - zugänglich innerhalb derselben Assembly
Fügen Sie einen Konstruktor hinzu, der username, password, email und userId akzeptiert. Fügen Sie eine public Methode namens GetPublicInfo() hinzu, die "User: {Username}" zurückgibt. Fügen Sie eine weitere public Methode namens ValidatePassword(string input) hinzu, die true zurückgibt, wenn die Eingabe mit dem privaten Passwort übereinstimmt, andernfalls false.
AdminProfile.cs: Erstellen Sie eine AdminProfile-Klasse im Namespace Security, die von UserProfile erbt. Diese Klasse zeigt, wie protected Member in abgeleiteten Klassen zugänglich werden. Der Konstruktor sollte dieselben vier Parameter akzeptieren und sie an den Basis-Konstruktor weitergeben. Fügen Sie eine public Methode namens GetAdminInfo() hinzu, die "Admin: {Username}, Email: {email}" zurückgibt - beachten Sie, dass Sie hier auf das geschützte email-Feld zugreifen können!
Program.cs: Erstellen Sie in Ihrer Hauptdatei ein UserProfile und ein AdminProfile unter Verwendung von Eingabewerten. Demonstrieren Sie die Zugriffsebenen, indem Sie die verfügbaren öffentlichen Methoden aufrufen und direkt auf das interne Feld zugreifen (da Sie sich in derselben Assembly befinden). Zeigen Sie, welche Informationen jeder Benutzertyp offenlegen kann.

Sie erhalten fünf Eingaben:

Username
Password
Email
User ID (Ganzzahl)
Passwortversuch zur Validierung

Geben Sie die Ausgabe in diesem Format aus:

Regular User:
{GetPublicInfo() result}
Internal ID: {userId}
Password valid: {ValidatePassword result}
Admin User:
{GetAdminInfo() result}

Wenn die Eingaben beispielsweise alice, secret123, alice@email.com, 1001 und secret123 sind, sollte die Ausgabe wie folgt aussehen:

Regular User:
User: alice
Internal ID: 1001
Password valid: True
Admin User:
Admin: alice, Email: alice@email.com

Beachten Sie, wie das Passwort vollständig verborgen bleibt - Sie können es nur validieren, niemals abrufen. Die E-Mail ist geschützt, sodass nur das AdminProfile (eine abgeleitete Klasse) sie offenlegen kann. Die interne userId ist von Ihrer Hauptdatei aus zugänglich, da sie sich in derselben Assembly befindet. Das ist Kapselung in Aktion!

Spickzettel

Zugriffsmodifikatoren steuern die Sichtbarkeit und Zugänglichkeit von Klassenmitgliedern und bilden die Grundlage der Kapselung in der OOP.

C# bietet vier Haupt-Zugriffsmodifikatoren:

public class BankAccount
{
    public string AccountHolder;      // Von überall zugänglich
    private decimal balance;          // Nur innerhalb dieser Klasse
    protected string accountType;     // Diese Klasse und abgeleitete Klassen
    internal int branchCode;          // Innerhalb derselben Assembly
}

public: von jedem Code aus zugänglich

private: nur innerhalb derselben Klasse zugänglich (am restriktivsten, Standard für Klassenmitglieder)

protected: zugänglich von der Klasse selbst und allen abgeleiteten Klassen

internal: nur innerhalb derselben Assembly (Projekt) zugänglich

Wenn kein Modifikator angegeben ist, sind Klassenmitglieder standardmäßig private:

class Example
{
    int secret;  // standardmäßig private
}

Best Practice: Beginnen Sie mit private und erhöhen Sie die Sichtbarkeit nur bei Bedarf, um zu verhindern, dass externer Code von Implementierungsdetails abhängig wird.

Probier es selbst

using System;
using Security;

class Program
{
    public static void Main(string[] args)
    {
        // Eingaben lesen
        string username = Console.ReadLine();
        string password = Console.ReadLine();
        string email = Console.ReadLine();
        int userId = Convert.ToInt32(Console.ReadLine());
        string passwordAttempt = Console.ReadLine();

        // TODO: Erstelle ein UserProfile-Objekt mit den Eingabewerten

        // TODO: Erstelle ein AdminProfile-Objekt mit denselben Eingabewerten

        // TODO: Gib "Regular User:" aus

        // TODO: Gib das Ergebnis von GetPublicInfo() aus

        // TODO: Gib "Internal ID: " gefolgt von dem Feld userId aus (zugänglich, da selbe Assembly)

        // TODO: Gib "Password valid: " gefolgt von dem Ergebnis von ValidatePassword() aus

        // TODO: Gib "Admin User:" aus

        // TODO: Gib das Ergebnis von GetAdminInfo() aus
    }
}