> ## 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# 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.
```csharp theme={"dark"}
[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
```csharp theme={"dark"}
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.
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
