Static vs Const vs Readonly in C# - A Beginner's Guide

In .NET development, you often need to define data that doesn't change or belongs to the class itself rather than a specific object. C# provides three keywords for these purposes: static, const, and readonly.

At first, all three may look similar because they are often used with variables or fields. However, they are completely different concepts and are used for different purposes.

What is Static in C#?

The static keyword belongs to the class itself rather than the object. Normally, when we create objects, each object gets its own copy of variables. But static members are shared among all objects.

Key Characteristics:

• Shared Memory: There is only one copy of a static variable in memory.
• Not a Constant: Unless combined with readonly, a static variable can be changed.
• Utility: Commonly used for counters, global settings, or helper methods (like Math.Sqrt()).

Example 1

Here is an example that shows the use of static variables.

public class User
{
    public static int TotalUsers = 0; // Shared by everyone

    public User()
    {
        TotalUsers++; // Every time a new user is made, the shared count goes up
    }
}

Example 2

class Employee
{
  public static string CompanyName = "ABC Technologies";
}

class Program
{
  static void Main()
  {
    // Note that we are not creating an objet here.
    Console.WriteLine(Employee.CompanyName);
  }
}

Output:

ABC Technologies

Here public static string CompanyName belongs to the class itself. We accessed it using Employee.CompanyName without creating an object.

What is Const in C#?

The const keyword is used for values that never change. Once a constant variable is assigned a value, it cannot be modified.

Key Characteristics:

• Compile-Time: The value must be assigned when you declare it. And the value should be a compile-time constant.
• Absolute: It cannot be changed by a constructor or any other method.
• Implicitly Static: You access it using the Class name (e.g., Configuration.MaxUsers), not an instance. In other words, we can say that a const is a static variable that cannot be changed.
• Performance: The compiler literally replaces the variable name with the value everywhere in your code, making it very fast.

Basic Example:

public class MathConstants
{
    public const double Pi = 3.14159; // Must assign here
}

// Usage
Console.WriteLine(MathConstants.Pi);

What is Readonly in C#?

A readonly field is a "run-time" constant. This means the value can be calculated or assigned when the application starts, but once assigned, it cannot be changed again.

Key Characteristics:

• Run-Time: You can assign the value in the Constructor. This allows you to set the value based on external data (like a database or user input).
• Instance-Based: By default, each object you create can have a different readonly value (unless you also make it static).
• Flexibility: It is safer for versioning than const.

public class Report
{
    public readonly DateTime CreatedAt;

    public Report()
    {
        // Assigned at run-time when the object is created and cannot be changed later.
        CreatedAt = DateTime.Now; 
    }
}

Summary Table

Practice Questions