Modificatori di accesso

Fa parte della sezione Programmazione orientata agli oggetti del percorso C# di Coddy. Lezione 31 di 70.

I modificatori di accesso controllano chi può vedere e usare i membri della tua classe. Sono alla base dell'incapsulamento, uno dei principi fondamentali della programmazione orientata agli oggetti (OOP). Limitando l'accesso, proteggi i tuoi dati e definisci confini chiari nel tuo codice.

C# offre quattro principali modificatori di accesso:

public class BankAccount
{
    public string AccountHolder;      // Accessibile da qualsiasi punto
    private decimal balance;          // Solo all'interno di questa classe
    protected string accountType;     // Questa classe e le classi derivate
    internal int branchCode;          // All'interno dello stesso assembly
}

I membri public sono accessibili da qualsiasi codice.

I membri private sono accessibili solo all'interno della stessa classe: questa è la visibilità più restrittiva ed è quella predefinita per i membri della classe.

protected consente l'accesso dalla classe stessa e da qualsiasi classe che eredita da essa.

internal limita l'accesso al codice all'interno dello stesso assembly (progetto).

Quando non viene specificato alcun modificatore, i membri della classe sono private per impostazione predefinita:

class Example
{
    int secret;  // privato per impostazione predefinita
}

Scegliere il livello di accesso giusto significa esporre solo ciò che è necessario. Inizia con private e aumenta la visibilità solo quando hai un motivo chiaro. Questo impedisce ad altro codice di dipendere da dettagli di implementazione che potresti voler modificare in seguito.

Sfida

Facile

Costruiamo un sistema sicuro di profili utente che mostri come i modificatori di accesso proteggono i dati sensibili, rendendo disponibili solo le informazioni necessarie. Creerai una classe in cui le diverse informazioni hanno livelli di visibilità differenti, in base a chi dovrebbe potervi accedere.

Organizzerai il codice in tre file:

UserProfile.cs: crea una classe UserProfile nello spazio dei nomi Security che gestisce le informazioni utente con livelli di accesso appropriati. Il profilo dovrebbe avere:
- Una proprietà public Username (string) - chiunque può vedere il nome utente
- Un campo private password (string) - solo la classe stessa dovrebbe potervi accedere
- Un campo protected email (string) - la classe e le sue classi derivate possono accedervi
- Un campo internal userId (int) - accessibile all'interno dello stesso assembly
Includi un costruttore che accetti username, password, email e userId. Aggiungi un metodo public chiamato GetPublicInfo() che restituisce "User: {Username}". Aggiungi un altro metodo public chiamato ValidatePassword(string input) che restituisce true se l'input corrisponde alla password privata, altrimenti false.
AdminProfile.cs: crea una classe AdminProfile nello spazio dei nomi Security che eredita da UserProfile. Questa classe mostra come i membri protected diventano accessibili nelle classi derivate. Il costruttore dovrebbe accettare gli stessi quattro parametri e passarli al costruttore della classe base. Aggiungi un metodo public chiamato GetAdminInfo() che restituisce "Admin: {Username}, Email: {email}" - nota che qui puoi accedere al campo email protected!
Program.cs: nel tuo file principale, crea un UserProfile e un AdminProfile usando i valori di input. Mostra i livelli di accesso chiamando i metodi pubblici disponibili e accedendo direttamente al campo internal (dato che ti trovi nello stesso assembly). Mostra quali informazioni può rivelare ciascun tipo di utente.

Riceverai cinque input:

Nome utente
Password
Email
ID utente (intero)
Tentativo di inserimento della password da convalidare

Stampa l'output in questo formato:

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

Ad esempio, se gli input sono alice, secret123, alice@email.com, 1001 e secret123, l'output dovrebbe essere:

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

Nota come la password rimanga completamente nascosta: puoi solo convalidarla, non recuperarla mai. L'email è protetta, quindi solo AdminProfile (una classe derivata) può mostrarla. Il campo internal userId è accessibile dal tuo file principale perché si trova nello stesso assembly. Questa è l'incapsulazione in azione!

Provalo tu

using System;
using Security;

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

        // TODO: Crea un oggetto UserProfile con i valori di input

        // TODO: Crea un oggetto AdminProfile con gli stessi valori di input

        // TODO: Stampa "Regular User:"

        // TODO: Stampa il risultato di GetPublicInfo()

        // TODO: Stampa "Internal ID: " seguito dal campo userId (accessibile perché si trova nello stesso assembly)

        // TODO: Stampa "Password valid: " seguito dal risultato di ValidatePassword()

        // TODO: Stampa "Admin User:"

        // TODO: Stampa il risultato di GetAdminInfo()
    }
}