Modificatori d’accesso in C#

I modificatori di accesso in C# sono fondamentali per la gestione della visibilità delle variabili e metodi all’interno del codice. Grazie a questi, puoi controllare chi può accedere a determinate informazioni o funzionalità di una classe o di un membro.

In C#, ci sono diversi tipi di modificatori di accesso, ciascuno con la propria funzione specifica. Ecco i principali:

• public: accessibile ovunque.
• private: accessibile solo all’interno della stessa classe.
• protected: accessibile all’interno della stessa classe e delle classi derivate.
• internal: accessibile all’interno dello stesso assembly (progetto).
• protected internal: combinazione di protected e internal, accessibile all’interno dello stesso assembly o dalle classi derivate.

Esempi di utilizzo dei modificatori

Ora vediamo come utilizzare ciascuno di questi modificatori di accesso con esempi pratici. Questo ti aiuterà a capire meglio come implementare questi concetti nel tuo codice.

Modificatore public:

Il modificatore public rende il membro accessibile da qualsiasi parte del codice, all’interno o all’esterno del progetto.

public class MyClass
{
    public string MyPublicProperty { get; set; }

    public void MyPublicMethod()
    {
        // Metodo accessibile ovunque
    }
}

Modificatore private:

Il modificatore private limita l’accesso ai membri solo all’interno della classe in cui sono dichiarati. Questo è utile per mantenere nascosti dettagli di implementazione.

public class MyClass
{
    private int myPrivateField;

    private void MyPrivateMethod()
    {
        // Accessibile solo all'interno della classe
    }
}

Modificatore protected:

Il modificatore protected consente l’accesso ai membri solo all’interno della classe e delle sue classi derivate.

public class MyBaseClass
{
    protected string MyProtectedProperty { get; set; }
}

public class MyDerivedClass : MyBaseClass
{
    public void AccessProtectedMember()
    {
        MyProtectedProperty = "Accessibile dalla classe derivata";
    }
}

Modificatore internal:

Il modificatore internal consente l’accesso ai membri solo all’interno dello stesso progetto (assembly). Non sono accessibili da altri progetti.

internal class MyInternalClass
{
    internal void MyInternalMethod()
    {
        // Accessibile solo all'interno dell'assembly
    }
}

Modificatore protected internal:

Il modificatore protected internal consente l’accesso ai membri sia dalle classi derivate che all’interno dello stesso progetto.

public class MyClass
{
    protected internal void MyProtectedInternalMethod()
    {
        // Accessibile all'interno dell'assembly o dalle classi derivate
    }
}

Utilizzo dei modificatori nei membri

Oltre che nelle classi, i modificatori di accesso vengono utilizzati anche nei membri di una classe, come campi, proprietà e metodi. Questo permette un controllo preciso su chi può accedere a questi elementi.

Esempio di modificatori nei membri:

Ecco un esempio che mostra come i modificatori possono essere applicati a vari membri all’interno di una classe.

public class MyClass
{
    public int MyPublicField;
    private string myPrivateField;
    protected bool MyProtectedField;

    internal void MyInternalMethod()
    {
        // Metodo accessibile solo all'interno dell'assembly
    }
}