C# Variables and Constants: var, const and readonly Explained

Storing data that changes — and data that stays the same — in C#.

Imagine you're building a calculator app. You need to store the numbers the user enters, the result of each operation, and maybe a fixed value like PI that never changes. Every time the user presses a button, the numbers in memory change — but PI stays exactly the same.

That's the core difference between variables and constants in C#. Variables hold data that can change as your program runs. Constants hold data that stays fixed forever.

Every C# program — from a simple console app to a massive enterprise system — uses variables and constants constantly. Understanding them is the first step toward writing real code that works with data.

What Is It?

The Simple Explanation

Variable = A named storage location in memory whose value can change during program execution.

Constant = A named storage location whose value is fixed at compile time and cannot change afterward.

The Technical Definition

Variables are named memory locations that store values. You declare a variable by specifying its type and name, and you can assign a value to it. The value can be changed any number of times during the program's lifetime.

Constants are values that are known at compile time and do not change for the entire lifetime of the program. They are declared using the const keyword and must be assigned a value at declaration. The compiler replaces constant references with their literal values during compilation.

Why Does It Exist?

The Problem

When you write a program, you need to work with data. A user's name, a bank balance, the current time, a product price — these are all pieces of information your program needs to store, retrieve, and manipulate.

Imagine if you had to remember the memory address of every piece of data you used. It would be nearly impossible to write any program larger than "Hello, World!"

The Solution

Variables give you a named way to refer to data. Instead of remembering that the user's age is at memory address 0x7FFD8A3F9C10, you can simply use the name age. Constants give you a way to give meaningful names to fixed values — so instead of writing 3.14159 everywhere, you write PI.

Big Picture

Here's how variables and constants fit into the C# type system and memory:

How It Works

Let's trace what happens when you declare and use variables and constants in C#:

Step 1 — Declare a variable

int age;  // Declaration — memory is reserved, but no value is set yet

You tell the compiler: "I need a storage location named age that can hold an int." The compiler reserves memory for it.

Step 2 — Initialize the variable

age = 25;  // Assignment — the value 25 is stored in the reserved memory

You write a value into the memory location. Now age holds the value 25.

Step 3 — Declare and initialize a constant

const double PI = 3.14159;  // Must be assigned at declaration

The compiler sees PI and replaces every use of PI with 3.14159 at compile time. No memory is allocated at runtime.

Step 4 — Use the variable and constant

double circumference = 2 * PI * radius;  // PI is replaced with 3.14159

The variable radius holds a value from user input or calculation. The constant PI provides the fixed mathematical value.

Simple Example

Here's a complete C# program showing variables and constants in action:

        // ── Variables ──
        string userName = "Alice";   // Can change later
        int score = 0;                // Starts at 0, can increase
        bool isGameOver = false;      // Tracks game state

        // ── Constants ──
        const int MAX_SCORE = 100;      // Fixed maximum
        const string GAME_TITLE = "Super C# Adventure";

        // ── Using them ──
        Console.WriteLine($"Welcome to {GAME_TITLE}, {userName}!");
        score += 10;                 // Variable changes

        if (score >= MAX_SCORE)        // Constant used in condition
        {
            isGameOver = true;
            Console.WriteLine($"You win, {userName}!");
        }
    

What's happening:

• userName, score, isGameOver are variables — their values can change as the game progresses.
• MAX_SCORE and GAME_TITLE are constants — their values are fixed and known at compile time.
• The variable score starts at 0 and increases by 10 each time the player scores.
• The constant MAX_SCORE sets the winning threshold — it never changes.

Real-World Example

Consider an e‑commerce checkout system. Here's how variables and constants would be used:

        // ── Constants (business rules that never change) ──
        const decimal TAX_RATE = 0.08m;              // 8% sales tax
        const decimal FREE_SHIPPING_THRESHOLD = 50.00m;
        const decimal STANDARD_SHIPPING = 5.99m;

        // ── Variables (data that changes per order) ──
        string customerName = "Jane Doe";
        var cartItems = new List<Product>();     // C# 14: collection expression
        decimal subtotal = 0.00m;
        decimal tax = 0.00m;
        decimal shipping = 0.00m;
        decimal total = 0.00m;

        // ── Calculate order totals ──
        foreach (var item in cartItems)
        {
            subtotal += item.Price * item.Quantity;   // Variable changes
        }

        tax = subtotal * TAX_RATE;                    // Constant used

        if (subtotal >= FREE_SHIPPING_THRESHOLD)      // Constant used
        {
            shipping = 0.00m;
        }
        else
        {
            shipping = STANDARD_SHIPPING;            // Constant used
        }

        total = subtotal + tax + shipping;            // Final variable

        // ── Output ──
        Console.WriteLine($"Order for {customerName}: ${total:F2}");
    

What's happening:

• Constants (TAX_RATE, FREE_SHIPPING_THRESHOLD, STANDARD_SHIPPING) represent fixed business rules that rarely change.
• Variables (customerName, subtotal, tax, shipping, total) hold data specific to each order.
• If the tax rate changes, you update the constant in one place — not every calculation.
• If the free shipping threshold changes, you change the constant and every order uses the new value.

Analogy

Under the Hood

Let's look at what actually happens in memory and at compile time when you use variables and constants:

int age = 25;
const double PI = 3.14159;

Memory Layout: Stack vs Heap

Common Confusion

const vs readonly

var vs explicit type

            var name = "Alice";   // name is string — compiler knows this
            name = 42;              //  Compiler error: can't assign int to string
        

Common Mistakes

                    int count;
                    Console.WriteLine(count);  //  Compiler error: unassigned local variable
                

                    int count = 0;
                    Console.WriteLine(count);  //  Works — outputs 0
                

                    const double PI = 3.14159;
                    PI = 3.14;  //  Compiler error: cannot assign to const
                

                    double pi = 3.14159;  // Variable — can change
                    pi = 3.14;  //  Works
                

                    const DateTime Now = DateTime.Now;  //  Compiler error: DateTime.Now is not a compile-time constant
                

                    static readonly DateTime Now = DateTime.Now;  //  Works
                

                    int a = 5;       // Value type — stored on stack
                    int b = a;       // Copy of value — b is 5, a is 5
                    a = 10;          // b is still 5 — separate copies

                    string s1 = "Hello";  // Reference type — stored on heap
                    string s2 = s1;    // Both point to the same string object
                    s1 = "Goodbye";  // s2 still points to "Hello" — strings are immutable
                

When Should I Use It?

Use variables when:

• You need to store data that can change — user input, calculation results, counters, state flags.
• You're working with data that comes from external sources (database, API, user).
• You need to accumulate values (totals, lists, strings being built).

Use constants when:

• The value is known at compile time and will never change — mathematical constants, fixed thresholds, API keys (in secure contexts).
• You want to give a meaningful name to a "magic number" — MAX_RETRIES instead of 3.
• You need the value to be inlined for performance (though this is rarely a primary concern).

Use readonly when:

• The value is set once and never changes, but it's not known at compile time — DateTime.Now, configuration values, dependency injections.
• You're working with reference types that need to be immutable after construction.

Mental Model

Key Takeaway

Check Your Understanding

You've seen how variables hold data that can change and constants hold fixed values. Let's test your understanding of when and how to use each.

            int x = 5;
            int y = x;
            x = 10;
            Console.WriteLine(y);
        

            string userName = "Alice";
            userName = "Bob";
            Console.WriteLine(userName);
        

You've mastered variables and constants — the foundation of working with data in C#!