What is the difference between a local variable, a const, a readonly field and a static readonly field in C#, and how do literals such as numeric suffixes, digit separators and raw string literals work?

1. What the compiler emits for each kind

Compile this and open it in ILSpy or SharpLab:

Source                          IL at the CALL SITE
------------------------------  -----------------------------------
const int Max = 50;             ldc.i4.s 50            // value copied
static readonly int Max = 50;   ldsfld int32 C::Max    // field load
readonly int _max;              ldarg.0
                                ldfld int32 C::_max    // field load
int local = 50;                 ldc.i4.s 50 / stloc.0  // local slot

The const disappears at the call site — the caller's IL contains the number itself. The defining assembly keeps a Constant metadata row (that is what reflection's FieldInfo.GetRawConstantValue() reads), but no running code consults it. This is why changing a public const is a binary breaking change even though it is source compatible.

Optional parameters behave identically: void Send(int retries = 3) compiles callers into Send(3). Change the default to 5 in v2 and existing callers still pass 3.

2. Definite assignment, step by step

The C# specification defines definite assignment as a flow analysis over the method body. At each point, the compiler knows whether each local is definitely assigned, definitely unassigned or maybe assigned.

int total;
if (flag) total = 1;           // assigned on the true branch only
Console.WriteLine(total);      // CS0165: maybe-unassigned here

int result = flag ? 1 : 0;     // assigned on every path - fine

out parameters reverse the rule: the callee must assign them on every non-throwing path (CS0177). Fields are not tracked because the runtime zeroes all object memory when allocating, which is why a new object's int field is 0 and reference fields are null.

The runtime also zeroes locals by default (the .locals init flag in IL). [SkipLocalsInit] removes that zeroing for performance-critical methods — useful with large stackalloc buffers — but definite-assignment rules in C# still apply.

3. How static readonly initialisation really works

• A static field initialiser (static readonly X = ...;) becomes code inside the type's static constructor (.cctor).
• If the type has no explicit static constructor, the compiler marks it beforefieldinit, which lets the runtime run the initialiser at any time before the first static field access (often eagerly). With an explicit static constructor, it runs exactly on first access to the type, which costs a small check on some paths.
• The runtime guarantees the .cctor runs once, under a lock, so static readonly is a thread-safe lazy singleton for free.
• If the .cctor throws, the type is permanently broken in that process: every subsequent access throws TypeInitializationException with the original exception as InnerException. A bad config value read in a static initialiser can take down an entire service until restart.

4. Why static readonly is now as fast as const

With tiered compilation (default since .NET Core 3.0) and dynamic PGO (default since .NET 8):

1. A method first runs as tier 0 (quick JIT, few optimisations).
2. After ~30 calls, or a hot loop via on-stack replacement, it is recompiled at tier 1.
3. By then the static constructor has run, so the JIT reads the actual value of static readonly fields and treats it as a constant: it folds arithmetic, removes dead branches (if (Config.FeatureEnabled)), and can devirtualise calls on static readonly object references.

So static readonly bool LoggingEnabled = ...; gives you dead-code elimination on par with const, while staying configurable. Measure with BenchmarkDotNet before arguing otherwise.

5. readonly on structs and defensive copies

When you call a method on a struct that the compiler cannot prove is unmodified — e.g. a non-readonly struct stored in a readonly field or passed by in — the compiler makes a hidden defensive copy first, so the method cannot mutate the original. For large structs on hot paths this costs real time.

public readonly struct Money(decimal amount, string currency)
{
    public decimal Amount { get; } = amount;
    public string Currency { get; } = currency;
}

Marking the struct (or individual members) readonly tells the compiler no copy is needed.

6. Literal typing rules in detail

Integer literals also convert implicitly to smaller types when the value fits: byte b = 200; compiles, byte b = 300; does not. Real literals never convert implicitly to decimal, because binary floating point cannot represent most decimal fractions exactly.

7. Raw string literals

string json = """
    {
      "name": "Ada",
      "tags": ["a", "b"]
    }
    """;

• The column of the closing """ defines how much leading whitespace is stripped from every line.
• If the content contains """, open with four quotes """" instead.
• In raw interpolated strings, the number of $ signs sets how many braces open a hole: $$"""{ "id": {{id}} }""" lets single braces stay literal — ideal for JSON templates.

Try it yourself

1. Create LibA with public const int Limit = 10; and public static readonly int Limit2 = 10;, and a console app that prints both.
2. Change both to 20, rebuild only LibA, copy the DLL into the app's bin folder, and run it: Limit prints 10, Limit2 prints 20.
3. Open the console app in ILSpy and find ldc.i4.s 10 versus ldsfld.
4. Add a static constructor that throws, access the field twice, and observe TypeInitializationException both times.

namespace Basics;

public static class Limits
{
    // Never changes: safe as const
    public const int BitsPerByte = 8;

    // May change between releases: static readonly
    public static readonly int MaxPageSize = 100;

    // Needs a runtime value: must be static readonly
    public static readonly TimeSpan HttpTimeout = TimeSpan.FromSeconds(30);
}

public sealed class Invoice(decimal amount)
{
    private readonly decimal _amount = amount;     // set once
    private readonly List<string> _notes = [];     // field is readonly, list is not

    public void AddNote(string note) => _notes.Add(note); // allowed
    // public void Reset() => _amount = 0;           // CS0191: cannot assign
}

public static class LiteralDemo
{
    public static void Run()
    {
        int million = 1_000_000;
        int mask = 0b_1111_0000;
        long big = 5_000_000_000;            // long without a suffix
        decimal price = 19.95m;              // m is required
        float ratio = 0.75f;
        string path = @"C:\logs\app.txt";
        string json = """
            { "name": "Ada", "active": true }
            """;
        ReadOnlySpan<byte> ok = "OK"u8;      // UTF-8 bytes, no allocation

        Console.WriteLine($"{million} {mask:X} {big} {price} {ratio} {path} {ok.Length}");
        Console.WriteLine(json);
    }
}