Internal Field

An internal field in C# is a class-level or struct-level variable declared with the internal access modifier, restricting its visibility and accessibility strictly to the current assembly (the compiled .dll or .exe file). Any type within the same assembly can access the field, though the ability to modify it depends on the absence of restrictive modifiers like readonly or const. Code in external assemblies referencing the compiled binary is completely denied access.

Syntax

public class NetworkConfig
{
    // Instance internal field (read/write within the assembly)
    internal int timeoutMilliseconds;

    // Static internal field
    internal static string defaultProtocol = "TCP";

    // Read-only internal field (read-only within the assembly after initialization)
    internal readonly int maxRetries = 3;
}

Technical Characteristics

• Assembly Boundary Enforcement: The C# compiler (Roslyn) enforces the internal constraint at compile-time. If AssemblyA.dll contains an internal field, classes in AssemblyB.dll attempting to access it will trigger a compile-time error (CS0122: is inaccessible due to its protection level). The Common Language Runtime (CLR) enforces this boundary at runtime, throwing a FieldAccessException if an external assembly attempts illegal access via Intermediate Language (IL) manipulation or unauthorized reflection.
• Default Accessibility: While top-level types (classes, structs) default to internal if no modifier is specified, fields within a type default to private. The internal keyword must be explicitly declared to elevate a field’s visibility to the assembly level.
• Memory Allocation: The internal modifier dictates access control, not memory management. An internal field’s memory allocation follows standard CLR rules based on its containing type and state:
  • Instance fields within a reference type (class) are allocated on the managed heap within their containing object’s memory layout.
  • Instance fields within a value type (struct) are allocated inline with the struct itself. If the struct is allocated on the stack (e.g., as a local variable), its internal fields are also allocated on the stack.
  • internal static fields are allocated in the High Frequency Heap associated with the type object, regardless of whether the containing type is a class or a struct.
• Modifier Combinations:
  • protected internal: Grants access to any code within the same assembly, as well as any derived classes located in external assemblies.
  • private protected: Grants access only to derived classes that are also located within the same assembly.
  • internal readonly / internal const: Grants assembly-wide visibility but restricts modification. readonly fields can only be modified during declaration or within the constructor, while const fields are evaluated at compile-time and can never be modified.

The InternalsVisibleTo Exception

The strict assembly boundary of an internal field can be bypassed using the System.Runtime.CompilerServices.InternalsVisibleTo assembly attribute. This explicitly grants a specified external assembly full access to all internal members, including fields, overriding the standard encapsulation rules.

This can be declared in a C# source file (such as AssemblyInfo.cs):

using System.Runtime.CompilerServices;

// Placed in a .cs file within the source assembly
[assembly: InternalsVisibleTo("ExternalAssembly.Name")]

Alternatively, starting with newer .NET SDKs, it can be configured directly in the source assembly’s .csproj file using MSBuild XML syntax:

<!-- Placed in the .csproj file -->
<ItemGroup>
    <InternalsVisibleTo Include="ExternalAssembly.Name" />
</ItemGroup>

Master C# with Deep Grasping Methodology!

Learn More