What is 'readonly' in C#? Difference Between 'const' and 'readonly'

Short Answer

In C#, readonly is a keyword used to declare fields that can only be assigned a value at the time of declaration or within the constructor of a class. Once assigned, the value cannot be changed. The key difference between readonly and const is that const values are set at compile time and cannot change, while readonly values are set at runtime (during object creation) and remain constant for the lifetime of the object.

Detailed Explanation with Examples

What is readonly?

The readonly keyword in C# is used to create fields that can only be assigned a value once—either at the time of declaration or within the constructor of the class. After initialization, the value of a readonly field cannot be modified. This makes readonly fields ideal for values that should remain constant throughout the lifetime of an object but are not known until runtime.

Example of readonly in Action

Let’s look at an example to understand how readonly works.

Step 1: Define a Class with readonly Fields

Here’s a Car class with three readonly fields: Make, Model, and ProductionYear. These fields are initialized in the constructor.

public class Car
{
    public readonly string Make;
    public readonly string Model;
    public readonly int ProductionYear;

    // Constructor to initialize readonly fields
    public Car(string make, string model, int productionYear)
    {
        Make = make;
        Model = model;
        ProductionYear = productionYear;
    }

    // Method to display car details
    public void DisplayCarDetails()
    {
        Console.WriteLine($"Make: {Make}, Model: {Model}, Production Year: {ProductionYear}");
    }
}

Step 2: Use the readonly Fields

In the Main method, we create two Car objects and initialize their readonly fields. Once initialized, these fields cannot be changed.

class Program
{
    static void Main()
    {
        // Create two Car objects
        Car car1 = new Car("Toyota", "Camry", 2022);
        Car car2 = new Car("Honda", "Civic", 2023);

        // Display car details
        car1.DisplayCarDetails(); // Output: Make: Toyota, Model: Camry, Production Year: 2022
        car2.DisplayCarDetails(); // Output: Make: Honda, Model: Civic, Production Year: 2023

        // Error: Cannot modify readonly fields after initialization
        // car1.ProductionYear = 2024; // This will cause a compile-time error
    }
}

In this example:

• The Make, Model, and ProductionYear fields are initialized in the constructor.
• Once initialized, these fields cannot be modified, ensuring their values remain constant for the lifetime of the object.

What is the Difference Between const and readonly?

While both const and readonly are used to create fields with constant values, they have key differences:

Example: const vs readonly

Let’s compare const and readonly in a practical example.

Step 1: Define a Class with const and readonly Fields

Here’s a Settings class with a const field (Pi) and a readonly field (AppVersion).

public class Settings
{
    // const field (must be assigned at declaration)
    public const double Pi = 3.14159;

    // readonly field (can be assigned in the constructor)
    public readonly string AppVersion;

    // Constructor to initialize readonly field
    public Settings(string appVersion)
    {
        AppVersion = appVersion;
    }

    // Method to display settings
    public void DisplaySettings()
    {
        Console.WriteLine($"Pi: {Pi}, App Version: {AppVersion}");
    }
}

Step 2: Use const and readonly Fields

In the Main method, we create an instance of the Settings class and display the values of the const and readonly fields.

class Program
{
    static void Main()
    {
        // Create a Settings object
        Settings settings = new Settings("1.0.0");

        // Display settings
        settings.DisplaySettings(); // Output: Pi: 3.14159, App Version: 1.0.0

        // Access const field directly through the class name
        Console.WriteLine($"Pi value: {Settings.Pi}"); // Output: Pi value: 3.14159

        // Error: Cannot modify const or readonly fields
        // Settings.Pi = 3.14; // Compile-time error
        // settings.AppVersion = "2.0.0"; // Compile-time error
    }
}

In this example:

• The const field Pi is assigned at declaration and cannot be changed.
• The readonly field AppVersion is assigned in the constructor and cannot be changed after initialization.

Key Points to Remember

• const:
  • Used for values that are known at compile time and never change.
  • Must be assigned at declaration.
  • Accessed through the class name (static by default).
• readonly:
  • Used for values that are known at runtime and should not change after initialization.
  • Can be assigned at declaration or in the constructor.
  • Can be instance-specific or static.
• When to Use:
  • Use const for fixed values like mathematical constants (e.g., Pi).
  • Use readonly for values that depend on runtime data (e.g., configuration settings).

Real-World Use Case: Configuration Settings

Imagine you’re building an application where the version number is set at runtime based on a configuration file. You can use a readonly field to store the version number, ensuring it remains constant after initialization.

public class AppConfig
{
    public readonly string Version;

    public AppConfig(string version)
    {
        Version = version;
    }

    public void DisplayVersion()
    {
        Console.WriteLine($"App Version: {Version}");
    }
}
	

Final Thoughts

Understanding the difference between const and readonly is essential for writing robust and maintainable C# code. Use const for values that are known at compile time and never change, and use readonly for values that are set at runtime and should remain constant for the lifetime of an object. Both keywords help enforce immutability, but they serve different purposes depending on the nature of the values they represent.