protected internal (Riferimenti per C#)

  • Articolo

La combinazione delle parole chiave protected internal è un modificatore di accesso ai membri. Un membro protected internal è accessibile dall'assembly corrente o dai tipi che derivano dalla classe che li contiene. Per un confronto di protected internal con altri modificatori di accesso, vedere Livelli di accessibilità.

Esempio

Un membro protected internal di una classe base è accessibile da qualsiasi tipo all'interno dell'assembly che lo contiene. È inoltre accessibile in una classe derivata che si trova in un altro assembly solo se l'accesso viene eseguito tramite una variabile del tipo di classe derivata. Si consideri il segmento di codice di esempio seguente:

// Assembly1.cs
// Compile with: /target:library
public class BaseClass
{
   protected internal int myValue = 0;
}

class TestAccess
{
    void Access()
    {
        var baseObject = new BaseClass();
        baseObject.myValue = 5;
    }
}

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
class DerivedClass : BaseClass
{
    static void Main()
    {
        var baseObject = new BaseClass();
        var derivedObject = new DerivedClass();

        // Error CS1540, because myValue can only be accessed by
        // classes derived from BaseClass.
        // baseObject.myValue = 10;

        // OK, because this class derives from BaseClass.
        derivedObject.myValue = 10;
    }
}

Questo esempio contiene due file, Assembly1.cs e Assembly2.cs. Il primo file contiene una classe base pubblica, BaseClass, e un'altra classe, TestAccess. BaseClass è proprietario di un membro protected internal, myValue, a cui si accede dal tipo TestAccess. Nel secondo file un tentativo di accedere a myValue tramite un'istanza di BaseClass produrrà un errore, mentre l'accesso a questo membro tramite un'istanza di una classe derivata, DerivedClass, avrà esito positivo.

I membri struct non possono essere protected internal perché struct non può essere ereditato.

Override dei membri interni protetti

Quando si esegue l'override di un membro virtuale, il modificatore di accessibilità del metodo sottoposto a override dipende dall'assembly in cui è definita la classe derivata.

Quando la classe derivata viene definita nello stesso assembly della classe di base, tutti i membri sottoposti a override hanno protected internal accesso. Se la classe derivata è definita in un assembly diverso dalla classe base, i membri sottoposti a override hanno protected accesso.

// Assembly1.cs
// Compile with: /target:library
public class BaseClass
{
    protected internal virtual int GetExampleValue()
    {
        return 5;
    }
}

public class DerivedClassSameAssembly : BaseClass
{
    // Override to return a different example value, accessibility modifiers remain the same.
    protected internal override int GetExampleValue()
    {
        return 9;
    }
}

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
class DerivedClassDifferentAssembly : BaseClass
{
    // Override to return a different example value, since this override
    // method is defined in another assembly, the accessibility modifiers
    // are only protected, instead of protected internal.
    protected override int GetExampleValue()
    {
        return 2;
    }
}

Specifiche del linguaggio C#

Per altre informazioni, vedere la specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.

Vedi anche