RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/protected below:

protected keyword - C# reference

The protected keyword is a member access modifier.

A protected member is accessible within its class and by derived class instances.

For a comparison of protected with the other access modifiers, see Accessibility Levels.

Example 1

A protected member of a base class is accessible in a derived class only if the access occurs through the derived class type. For example, consider the following code segment:

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

The statement baseObject.myValue = 10 generates an error because it accesses the protected member through a base class reference (baseObject is of type BaseClass). Protected members can only be accessed through the derived class type or types derived from it.

Unlike private protected, the protected access modifier allows access from derived classes in any assembly. Unlike protected internal, it does not allow access from non-derived classes within the same assembly.

Struct members cannot be protected because the struct cannot be inherited.

Example 2

In this example, the class DerivedPoint is derived from Point. Therefore, you can access the protected members of the base class directly from the derived class.

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
}

If you change the access levels of x and y to private, the compiler will issue the error messages:

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

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

Cross-assembly access

The following example demonstrates that protected members are accessible from derived classes even when they're in different assemblies:

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

This cross-assembly accessibility is what distinguishes protected from private protected (which restricts access to the same assembly) but is similar to protected internal (though protected internal also allows same-assembly access from non-derived classes).

C# language specification

For more information, see Declared accessibility in the C# Language Specification. The language specification is the definitive source for C# syntax and usage.