Const And Read Only Keywords In C# Complete Guide

Understanding const and readonly Keywords

1. const Keyword

• const is used to declare constants.
• Constants are values that, once assigned, cannot be changed throughout the program.
• const fields must be initialized at the time of declaration.
• const can only contain value types (int, double, char, etc.), strings (System.String), and null references.

2. readonly Keyword

• readonly is used to declare read-only fields.
• Read-only fields can have their values set only during object instantiation or inside a constructor of the class.
• They can also be set to a static value during field initialization.
• Unlike const, readonly can be used with reference types (including user-defined classes).

Example Scenario

Let's say you are building a software application for a library where you need to define certain fixed constants (like tax or fees) and some values that should not change after an instance is created (like the library name or book ID).

Step-by-Step Examples

Step 1: Using const

Define a Constant

using System;

class LibraryConstants
{
    // Defining a constant
    public const double LateFeePerDay = 1.50;
    public const string LibraryName = "Central Library";

    static void Main(string[] args)
    {
        Console.WriteLine("Library Name: " + LibraryName);
        Console.WriteLine("Late Fee Per Day: $" + LateFeePerDay);

        // Trying to modify a const value will result in a compile-time error
        // LateFeePerDay = 1.75; // Uncommenting this line will cause a compilation error
    }
}

Explanation:

• const double LateFeePerDay = 1.50; - Declares a constant named LateFeePerDay with a value of 1.50.
• const string LibraryName = "Central Library"; - Declares a string constant named LibraryName with a value of "Central Library".
• You can access these constants using the class name, such as LibraryConstants.LateFeePerDay.
• You cannot change the value of these constants after they are initialized because any attempt to do so will result in a compile-time error.

Output:

Library Name: Central Library
Late Fee Per Day: $1.5

Step 2: Using readonly with Instance Variables

Define a Readonly Field

using System;

class Library
{
    // Declaring a readonly instance variable
    private readonly string bookId;

    // Constructor to initialize readonly variables
    public Library(string id)
    {
        bookId = id;
    }

    // Method to display the Book ID
    public void DisplayBookId()
    {
        Console.WriteLine("Book ID: " + bookId);
    }

    static void Main(string[] args)
    {
        Library myLibrary = new Library("LIB001");
        myLibrary.DisplayBookId();

        // Trying to modify a readonly field outside its initializer will result in a compile-time error
        // myLibrary.bookId = "LIB002"; // Uncommenting this line will cause a compilation error
    }
}

Explanation:

• private readonly string bookId; - Declares a readonly instance variable named bookId.
• The readonly variable bookId is initialized through the constructor public Library(string id).
• You can display the value of bookId using the DisplayBookId method.
• Once bookId is initialized, it cannot be changed outside its initializer (constructor in this case).

Output:

Book ID: LIB001

Step 3: Using readonly with Static Variables

Define a Static Readonly Variable

using System;

class Library
{
    // Declaring a readonly static variable
    private static readonly string LibraryLocation = "123 Elm Street";

    // Constructor
    public Library() { }

    // Static method to display the Library Location
    public static void DisplayLibraryLocation()
    {
        Console.WriteLine("Library Location: " + LibraryLocation);
    }

    static void Main(string[] args)
    {
        Library.DisplayLibraryLocation();

        // Trying to modify a static readonly field outside its initializer will result in a compile-time error
        // Library.LibraryLocation = "456 Oak Avenue"; // Uncommenting this line will cause a compilation error
    }
}

Explanation:

• private static readonly string LibraryLocation = "123 Elm Street"; - Declares a static readonly variable named LibraryLocation and initializes it.
• DisplayLibraryLocation is a static method that accesses the static readonly field LibraryLocation.
• A static readonly variable can only be modified during field initialization or within a static constructor.

Output:

Library Location: 123 Elm Street

Step 4: Using const and readonly Together

Define Both const and readonly Fields

using System;

class Library
{
    // Declaring a static const variable
    private static const int MaxBooksPerUser = 5;

    // Declaring a static readonly variable
    private static readonly DateTime LibraryEstablishedDate = new DateTime(2001, 1, 1);

    // Constructor
    public Library() { }

    // Static method to display maximum books per user and library established date
    public static void DisplayLibraryInfo()
    {
        Console.WriteLine("Maximum Books Per User: " + MaxBooksPerUser);
        Console.WriteLine("Library Established Date: " + LibraryEstablishedDate.ToShortDateString());
    }

    static void Main(string[] args)
    {
        Library.DisplayLibraryInfo();

        // Trying to modify these fields will result in compilation errors
        // MaxBooksPerUser = 6; // Uncommenting this line will cause a compilation error
        // LibraryEstablishedDate = new DateTime(2010, 1, 1); // Uncommenting this line will cause a compilation error
    }
}

Explanation:

• private static const int MaxBooksPerUser = 5; - Declares a static const variable named MaxBooksPerUser with a static value.
• private static readonly DateTime LibraryEstablishedDate = new DateTime(...) - Declares a static readonly variable named LibraryEstablishedDate with a date value.
• DisplayLibraryInfo is a static method that displays the values of MaxBooksPerUser and LibraryEstablishedDate.

Output:

Maximum Books Per User: 5
Library Established Date: 1/1/2001

Key Points to Remember

• const:

  • Used for compile-time constants.
  • Can be of primitive data types (int, double, char), strings, or null.
  • Must be initialized at the point of declaration.
  • Cannot be modified afterward.
  • Typically accessed via class name (e.g., ClassName.ConstantName).

• readonly:

  • Allows values to be set only once—either during initialization or in a constructor.
  • Can be used for both static and instance fields.
  • More flexible than const as it can hold complex data structures (if they are value types like structs).
  • Useful when the value needs to be determined at runtime but should remain immutable thereafter.