Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
The protected
keyword is a member access modifier.
Note
This page covers protected
access. The protected
keyword is also part of the protected internal
and private protected
access modifiers.
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.