Dela via

skyddad (C#-referens)

Nyckelordet protected är en medlemsåtkomstmodifierare.

Anmärkning

Den här sidan täcker protected åtkomst. Nyckelordet protected är också en del av protected internal och private protected åtkomstmodifierare.

En skyddad medlem är tillgänglig inom sin klass och för instanser av härledda klasser.

En jämförelse av protected med de andra åtkomstmodifierarna finns i Hjälpmedelsnivåer.

Exempel 1

En skyddad medlem i en basklass är endast tillgänglig i en härledd klass om åtkomsten sker via den härledda klasstypen. Tänk till exempel på följande kodsegment:

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

baseObject.myValue = 10 Instruktionen genererar ett fel eftersom den kommer åt den skyddade medlemmen via en basklassreferens (baseObject är av typen BaseClass). Skyddade medlemmar kan bara nås via den härledda klasstypen eller typer som härleds från den.

Till skillnad från private protectedtillåter protected åtkomstmodifieraren åtkomst från härledda klasser i alla sammansättningar. Till skillnad från protected internaltillåter den inte åtkomst från icke-härledda klasser inom samma sammansättning.

Struct-medlemmar kan inte skyddas eftersom structen inte kan ärvas.

Exempel 2

I det här exemplet härleds klassen DerivedPoint från Point. Därför kan du komma åt de skyddade medlemmarna i basklassen direkt från den härledda klassen.

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
}

Om du ändrar åtkomstnivåerna x för och y till privat utfärdar kompilatorn felmeddelandena:

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

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

Åtkomst mellan sammansättningar

I följande exempel visas att protected medlemmar är tillgängliga från härledda klasser även när de finns i olika sammansättningar:

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

Den här korssammansättningstillgängligheten är det som skiljer sig protected från private protected (vilket begränsar åtkomsten till samma sammansättning) men liknar protected internal (men protected internal tillåter även åtkomst med samma sammansättning från icke-härledda klasser).

Språkspecifikation för C#

Mer information finns i Deklarerad tillgänglighet i C#-språkspecifikationen. Språkspecifikationen är den slutgiltiga källan för C#-syntax och -användning.

Se även