Prev Next

Variable Modifiers

Modifiers in C# are keywords that provide additional control over the behavior of variables. They help enforce constraints on how variables can be used in the program. Some common modifiers include readonly, const, and static, each of which affects the variable's behavior differently.

Key Concepts

  • readonly: This modifier ensures that the variable can only be assigned a value once, either during declaration or in a constructor.
  • const: A variable marked as const must be assigned a value at the time of declaration and cannot be changed afterward. const is inherently static.
  • static: The static modifier makes the variable belong to the class itself, not to instances of the class, and is shared across all instances.
  • volatile: This modifier is used for variables that can be modified by different threads. It ensures the variable's value is read from memory directly, bypassing optimizations.

Examples of Using Variable Modifiers

Example 1: readonly Modifier

class Program
{
    // A readonly variable (can only be assigned once)
    public readonly int id;

    // Constructor to initialize readonly variable
    public Program(int newId)
    {
        id = newId; // Assigning in the constructor
    }

    static void Main(string[] args)
    {
        Program program = new Program(1001);
        Console.WriteLine($"ID: {program.id}");
    }
}

Output:

ID: 1001

Explanation: The readonly variable id is initialized either at the time of declaration or in the constructor. Once assigned, it cannot be changed later. This ensures the variable remains constant after initialization, except during object construction.

Example 2: const Modifier

class Program
{
    // A constant variable (must be assigned at declaration)
    public const double Pi = 3.14159;

    static void Main(string[] args)
    {
        // Accessing constant variable
        Console.WriteLine($"Value of Pi: {Pi}");
    }
}

Output:

Value of Pi: 3.14159

Explanation: The const modifier ensures that the variable Pi is constant and cannot be changed once declared. It must be assigned a value at the time of declaration and is implicitly static, meaning it can be accessed without creating an instance of the class.

Example 3: static Modifier

class Program
{
    // A static variable (shared across instances)
    public static string companyName = "TechCorp";

    static void Main(string[] args)
    {
        // Accessing static variable without creating an instance
        Console.WriteLine($"Company: {companyName}");
    }
}

Output:

Company: TechCorp

Explanation: The static modifier makes companyName a class-level variable that can be accessed without creating an instance of the class. All instances of the class share this variable, meaning it holds the same value across all instances.

Example 4: volatile Modifier

class Program
{
    // Volatile variable (used in multi-threaded environment)
    private static volatile bool isRunning = true;

    static void Main(string[] args)
    {
        // Accessing the volatile variable
        while (isRunning)
        {
            Console.WriteLine("Program is running...");
            isRunning = false; // Simulating a stop condition
        }
    }
}

Output:

Program is running...

Explanation: The volatile modifier ensures that the variable isRunning is always read from memory, ensuring visibility across threads in a multi-threaded environment. It is used here to control the execution of a loop, where isRunning changes dynamically.

Prev Next