Partilhar via

protegido (Referência C#)

A protected palavra-chave é um modificador de acesso a membros.

Observação

Esta página trata do protected acesso. A palavra-chave protected também faz parte dos modificadores de acesso protected internal e private protected.

Um membro protegido é acessível dentro de sua classe e por instâncias de classe derivadas.

Para obter uma comparação com os outros modificadores de acesso, consulte Níveis de protectedacessibilidade.

Exemplo 1

Um membro protegido de uma classe base é acessível em uma classe derivada somente se o acesso ocorrer por meio do tipo de classe derivada. Por exemplo, considere o seguinte segmento de código:

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

A instrução baseObject.myValue = 10 gera um erro porque acessa o membro protegido por meio de uma referência de classe base (baseObject is of type BaseClass). Os membros protegidos só podem ser acessados por meio do tipo de classe derivado ou tipos derivados dele.

Ao contrário de private protected, o modificador de acesso protected permite o acesso de classes derivadas em qualquer assembly. Ao contrário de protected internal, ele não permite o acesso de classes não derivadas que estão dentro do mesmo assembly.

Os membros do struct não podem ser protegidos porque o struct não pode ser herdado.

Exemplo 2

Neste exemplo, a classe DerivedPoint é derivada de Point. Portanto, você pode acessar os membros protegidos da classe base diretamente da classe derivada.

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 alterar os níveis de acesso de x e y para private, o compilador emitirá as mensagens de erro:

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

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

Acesso entre montagens

O exemplo a seguir demonstra que protected os membros são acessíveis a partir de classes derivadas mesmo quando estão em assemblies diferentes:

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

Essa acessibilidade entre montagens é o que distingue protected de private protected (que restringe o acesso ao mesmo assembly), mas é semelhante a protected internal (embora protected internal também permita o acesso ao mesmo assembly de classes não derivadas).

Especificação da linguagem C#

Para obter mais informações, consulte Acessibilidade declarada na Especificação de linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso do C#.

Ver também

  • Last updated on