Difference between static, readonly, and constant in C#

Question

Ravi Vishwakarma · Answer

In C#, static, read-only, and const are all keywords used to create members of classes or variables with different behaviors. They serve distinct purposes and have different behaviors.

Static:

Purpose: The static keyword is used to declare static members that belong to the type itself rather than to any specific instance of the type.
Behavior: Static members are shared among all instances of a class and we can access directly through the class name without creating an instance.
Initialization: They are initialized only once, typically at the time of the first access, and retain their value throughout the lifetime of the application.
Example: Commonly used for methods, fields, or properties that are not dependent on instance state, such as utility methods, constants, or shared resources.

Example

public class MyClass
{
    public static int Count = 0; // Static field
    public static void IncrementCount() // Static method
    {
        Count++;
    }
}

Readonly:

Purpose: The readonly keyword is used to define fields that can only be assigned a value at the time of declaration or within the constructor of that class.
Behavior: Readonly fields cannot be modified after initialization, providing a way to create immutable fields that retain their value throughout the object's lifetime.
Initialization: Readonly fields can only be assigned a value during declaration or within the constructor of the class, and their value cannot be changed afterward.
Example: Useful for creating immutable fields or constants that are known at runtime but cannot be known at compile time (unlike const).

Example :

public class MyClass
{
    public readonly int MaxValue; // Readonly field

    public MyClass(int value)
    {
        MaxValue = value; // Can only be assigned in the constructor
    }
}

Const:

Purpose: The const keyword is used to declare constant members or variables, which are values that are known at compile time and cannot be changed afterward.
Behavior: Const values are replaced directly by their values at compile time wherever they are referenced in the code.
Initialization: Const fields must be initialized with a value at the time of declaration and cannot be assigned a value elsewhere.
Example: Used for defining values that are not expected to change during the execution of the program and can be known at compile time.

Example -

public class Constants
{
    public const double PI = 3.14159; // Const field
}

Differences:

Mutability: Static fields can be modified after initialization, while readonly fields and constants cannot be changed after initialization.
Initialization: Static fields are initialized only once, typically at the time of the first access, while readonly fields and constants must be initialized either at the time of declaration or within the constructor.
Value Assignment: Readonly fields can be assigned a value either at declaration or within the constructor, while constants must be assigned a value at the time of declaration.
Scope: Static members belong to the type itself, while readonly fields and constants belong to individual instances of the type.

Use static for shared members, readonly for immutable instance fields, and const for compile-time constants whose values are known at compile time. Each serves a distinct purpose in C# programming and helps in designing maintainable and efficient code.

interview

Difference between static, readonly, and constant in C#

Can you answer this question?

1 Answers

Static:

Readonly:

Const:

Differences: