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

Erstellen wir ein sicheres Benutzerprofilsystem, das demonstriert, wie Zugriffsmodifizierer sensible Daten schützen und gleichzeitig nur das Notwendige offenlegen. Du erstellst eine Klasse, in der verschiedene Informationen unterschiedliche Sichtbarkeitsebenen haben, abhängig davon, wer darauf zugreifen können soll.

Du organisierst deinen Code über drei Dateien:

UserProfile.cs: Erstelle eine UserProfile-Klasse im Security-Namespace, die Benutzerinformationen mit geeigneten Zugriffsebenen verwaltet. Das Profil sollte Folgendes enthalten:
- 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 abgeleiteten Klassen können darauf zugreifen
- Ein internal-Feld userId (int) – innerhalb derselben Assembly zugänglich
Füge einen Konstruktor hinzu, der username, password, email und userId entgegennimmt. Füge eine public-Methode namens GetPublicInfo() hinzu, die "User: {Username}" zurückgibt. Füge außerdem 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: Erstelle eine AdminProfile-Klasse im Security-Namespace, die von UserProfile erbt. Diese Klasse demonstriert, wie protected-Member in abgeleiteten Klassen zugänglich werden. Der Konstruktor sollte dieselben vier Parameter akzeptieren und sie an den Basiskonstruktor übergeben. Füge eine public-Methode namens GetAdminInfo() hinzu, die "Admin: {Username}, Email: {email}" zurückgibt – beachte, dass du hier auf das geschützte email-Feld zugreifen kannst!
Program.cs: Erstelle in deiner Hauptdatei mithilfe von Eingabewerten eine UserProfile- und eine AdminProfile-Instanz. Demonstriere die Zugriffsebenen, indem du die verfügbaren öffentlichen Methoden aufrufst und direkt auf das interne Feld zugreifst (da du dich in derselben Assembly befindest). Zeige, welche Informationen jeder Benutzertyp offenlegen kann.

Du erhältst fünf Eingaben:

Benutzername
Passwort
E-Mail
Benutzer-ID (Ganzzahl)
Zu überprüfender Passwortversuch

Gib 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 lauten, sollte die Ausgabe folgendermaßen aussehen:

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

Beachte, dass das Passwort vollständig verborgen bleibt – du kannst es nur überprüfen, niemals abrufen. Die E-Mail ist geschützt, daher kann nur AdminProfile (eine abgeleitete Klasse) sie offenlegen. Die interne userId ist aus deiner Hauptdatei zugänglich, weil sie sich in derselben Assembly befindet. Das ist Kapselung in Aktion!

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