Condividi tramite

protected (Riferimento C#)

La protected parola chiave è un modificatore di accesso ai membri.

Annotazioni

Questa pagina illustra protected l'accesso. La protected parola chiave fa anche parte dei protected internal modificatori di accesso e private protected .

Un membro protetto è accessibile all'interno della relativa classe e dalle istanze della classe derivata.

Per un confronto con gli altri modificatori di protected accesso, vedere Livelli di accessibilità.

Esempio 1

Un membro protetto di una classe base è accessibile in una classe derivata solo se l'accesso avviene tramite il tipo di classe derivata. Si consideri ad esempio il segmento di codice seguente:

namespace Example1
{
    class BaseClass
    {
        protected int myValue = 123;
    }

    class DerivedClass : BaseClass
    {
        static void Main()
        {
            var baseObject = new BaseClass();
            var derivedObject = new DerivedClass();

            // Error CS1540, because myValue can only be accessed through
            // the derived class type, not through the base class type.
            // baseObject.myValue = 10;

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

L'istruzione baseObject.myValue = 10 genera un errore perché accede al membro protetto tramite un riferimento alla classe di base (baseObject è di tipo BaseClass). È possibile accedere ai membri protetti solo tramite il tipo di classe o i tipi derivati da esso.

A differenza di private protected, il protected modificatore di accesso consente l'accesso da classi derivate in qualsiasi assembly. A differenza di protected internal, non consente l'accesso da classi non derivate all'interno dello stesso assembly.

I membri dello struct non possono essere protetti perché lo struct non può essere ereditato.

Esempio 2

In questo esempio la classe DerivedPoint è derivata da Point. Pertanto, è possibile accedere ai membri protetti della classe base direttamente dalla classe derivata.

namespace Example2
{
    class Point
    {
        protected int x;
        protected int y;
    }

    class DerivedPoint: Point
    {
        static void Main()
        {
            var dpoint = new DerivedPoint();

            // Direct access to protected members.
            dpoint.x = 10;
            dpoint.y = 15;
            Console.WriteLine($"x = {dpoint.x}, y = {dpoint.y}");
        }
    }
    // Output: x = 10, y = 15
}

Se si modificano i livelli di accesso di x e y in privato, il compilatore genererà i messaggi di errore:

'Point.y' is inaccessible due to its protection level.

'Point.x' is inaccessible due to its protection level.

Accesso tra assembly diversi

L'esempio seguente illustra che protected i membri sono accessibili dalle classi derivate anche quando si trovano in assembly diversi:

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

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
namespace Assembly2
{
    using Assembly1;
    
    class DerivedClass : BaseClass
    {
        void Access()
        {
            // OK, because protected members are accessible from
            // derived classes in any assembly
            myValue = 10;
        }
    }
}

Questa accessibilità tra assembly è ciò che distingue protected da private protected (che limita l'accesso allo stesso assembly) ma è simile a protected internal (anche se protected internal consente anche l'accesso allo stesso assembly da classi non derivate).

Specificazione del linguaggio C#

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

Vedere anche

  • Last updated on