Constant Field

A constant field in C# is a variable whose value is evaluated and fixed at compile-time, rendering it strictly immutable throughout the application’s lifecycle. Declared using the const modifier, these fields are embedded directly into the Intermediate Language (IL) code wherever they are referenced, rather than being allocated as memory locations at runtime.

[access_modifier] const [data_type] [identifier] = [compile_time_expression];

Technical Characteristics

• Compile-Time Evaluation: The expression assigned to a constant must be fully resolvable by the compiler. It cannot rely on runtime calculations, method returns, or instance state.
• Implicitly Static: Constant fields belong to the type itself, not to instances of the type. They are accessed via the class name, and the static modifier is not allowed (and implicitly applied) in their declaration.
• Mandatory Initialization: A constant must be initialized in the exact same statement where it is declared. It cannot be assigned in a constructor.
• Type Restrictions: Only built-in value types (e.g., int, double, bool), char, string, and enum types can be declared as constants. Reference types (other than string) can only be declared as const if their assigned value is explicitly null.

Syntax Visualization

public class SystemDefinitions
{
    // Valid primitive and string constants
    public const double Pi = 3.14159;
    private const int MaxTimeoutMs = 5000;
    internal const string DefaultUser = "admin";
    
    // Constants can be computed using other constants
    public const double DoublePi = Pi * 2; 

    // Invalid: Cannot use runtime evaluation (e.g., DateTime.Now)
    // public const DateTime StartupTime = DateTime.Now; 

    // Invalid: Reference types must be null
    // public const object LockObj = new object();
    public const object NullReference = null;
}

public class Execution
{
    public void Run()
    {
        // Accessed via the type name, not an object instance
        double currentPi = SystemDefinitions.Pi;
    }
}

Compiler Behavior and Versioning

Because constants are evaluated at compile-time, the C# compiler performs literal substitution. When a constant is referenced, the compiler replaces the identifier with the actual literal value in the emitted IL.

This creates a strict versioning behavior across assembly boundaries: if Assembly A references a const from Assembly B, the literal value is baked into Assembly A’s compiled binary. If Assembly B updates the constant’s value and is recompiled, Assembly A will continue to use the old, baked-in value until Assembly A is also recompiled against the new version of Assembly B.

Master C# with Deep Grasping Methodology!

Learn More