> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# Protected Internal Method
A `protected internal` method in C# is a class member whose access level is the logical union of the `protected` and `internal` access modifiers. It can be invoked by any code within the same assembly in which it is declared, or by any derived class located in a different assembly.
Unlike `private protected` (which requires a caller to be *both* in the same assembly *and* a derived class), `protected internal` grants access if *either* condition is met.
## Syntax
The modifiers can be applied in either order (`protected internal` or `internal protected`), though `protected internal` is the standard convention.
```csharp theme={"dark"}
public class BaseClass
{
protected internal void ProcessData()
{
// Method implementation
}
}
```
## Access Rules and Compilation Boundaries
The compiler enforces the following strict access boundaries for a `protected internal` method:
1. **Within the Declaring Assembly:** The method behaves exactly like an `internal` method. It can be accessed by any type (class, struct, etc.) within the same compiled `.dll` or `.exe`, regardless of inheritance.
2. **Outside the Declaring Assembly:** The method behaves exactly like a `protected` method. It is only accessible to types that derive from the declaring class. Furthermore, within that external derived class, the method can only be accessed through an instance of the derived class type (or a type derived from it), not through an instance of the base class type.
## Code Visualization
The following example demonstrates the compiler's behavior across two distinct assemblies.
```csharp theme={"dark"}
// =========================================
// Assembly A
// =========================================
public class BaseClass
{
protected internal void Execute()
{
}
}
public class UnrelatedClassInSameAssembly
{
public void InvokeMethod()
{
var instance = new BaseClass();
// ALLOWED: Satisfies the 'internal' condition.
instance.Execute();
}
}
// =========================================
// Assembly B
// References Assembly A
// =========================================
public class DerivedClass : BaseClass
{
public void InvokeMethod()
{
// ALLOWED: Satisfies the 'protected' condition.
this.Execute();
var baseInstance = new BaseClass();
// ERROR CS1540: Cannot access protected member via a qualifier of type 'BaseClass'.
// baseInstance.Execute();
}
}
public class UnrelatedClassInDifferentAssembly
{
public void InvokeMethod()
{
var instance = new BaseClass();
// ERROR CS0122: 'BaseClass.Execute()' is inaccessible due to its protection level.
// instance.Execute();
}
}
```
## Inheritance and Overriding
When a `protected internal` virtual method is overridden in a derived class located in a *different* assembly, the overriding method must be declared as `protected`. It cannot be declared as `protected internal` because doing so would illegally expand the method's visibility to unrelated, non-derived classes within the derived class's assembly (Assembly B).
```csharp theme={"dark"}
// Assembly A
public class BaseClass
{
protected internal virtual void Initialize() { }
}
// Assembly B
public class DerivedClass : BaseClass
{
// Must be 'protected', not 'protected internal'
protected override void Initialize()
{
base.Initialize();
}
}
```
### The `[InternalsVisibleTo]` Exception
The strict overriding rule changes completely if the base assembly explicitly grants internal visibility to the derived assembly using the `[InternalsVisibleTo]` attribute.
If Assembly A uses `[assembly: InternalsVisibleTo("AssemblyB")]`, the derived class in Assembly B is granted visibility into Assembly A's `internal` scope. Because the derived class now sees the `internal` modifier of the base method, the compiler mandates that the override **must** be declared as `protected internal` to match the base signature's effective accessibility.
```csharp theme={"dark"}
// Assembly A
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("AssemblyB")]
public class BaseClass
{
protected internal virtual void Initialize() { }
}
// Assembly B
public class DerivedClass : BaseClass
{
// Must be 'protected internal' due to InternalsVisibleTo
protected internal override void Initialize()
{
base.Initialize();
}
}
```
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
