C# - Variables

Variables in C#

In C#, variables are classified into several types based on their scope, lifetime, and the type of data they hold. Here are the main types of variables in C#:

What are the Types of Variables in C#

We can store below datatypes in variables

• int - stores integers (whole numbers), without decimals, such as 123 or -123
• double - stores floating point numbers, with decimals, such as 19.99 or -19.99
• char - stores single characters, such as 'a' or 'B'. Char values are surrounded by single quotes
• string - stores text, such as "Hello World". String values are surrounded by double quotes
• bool - stores values with two states: true or false

Types and how to use variables

1. Local Variables

Scope: Local variables are declared inside a method, constructor, or block.

Lifetime: They exist only during the execution of the block or method in which they are declared.

Initialization: They must be initialized before use

void MyMethod()
{
    int localVar = 10;
    Console.WriteLine(localVar);
}

 2. Instance Variables (Fields)

Scope: Instance variables are declared inside a class but outside any method, constructor, or block.

Lifetime: They are associated with an instance of the class and exist for the lifetime of the object.

Initialization: They can be initialized when declared or in the constructor.

public class MyClass
{
    public int instanceVar = 20;
}

3. Static Variables (Static Fields)

Scope: Static variables are declared with the static keyword inside a class.

Lifetime: They belong to the class rather than any instance and exist for the lifetime of the application domain.

Initialization: They can be initialized when declared or in a static constructor.

public class MyClass
{
    public static int staticVar = 30;
}

4. Constant Variables

Scope: Constant variables are declared with the const keyword and must be initialized at the time of declaration.

Lifetime: They are implicitly static and exist for the lifetime of the application domain.

Initialization: They cannot be changed after initialization.

public class MyClass
{
    public const int constantVar = 40;
}

5. Read-Only Variables
Scope: Read-only variables are declared with the readonly keyword. They can be initialized either at the time of declaration or in a constructor.

Lifetime: Instance read-only variables exist for the lifetime of the object, while static read-only variables exist for the lifetime of the application domain.

Initialization: Their value can be set only once, either in the declaration or in the constructor.

public class MyClass
{
    public readonly int readOnlyVar;
    public MyClass(int value)
    {
        readOnlyVar = value;
    }
}

6. Ref and Out Variables

Scope: ref and out variables are used to pass arguments by reference to methods.

Lifetime: They exist for the duration of the method call.

Initialization: ref variables must be initialized before being passed, while out variables must be initialized inside the called method.

void MyMethod(ref int refVar, out int outVar)
{
    refVar = 50;
    outVar = 60;
}

7. Dynamic Variables

Scope: Dynamic variables are declared using the dynamic keyword and can store any type of data.

Lifetime: They exist for the scope in which they are declared.

Initialization: They can be initialized with any value and can change type at runtime.

dynamic dynamicVar = 70;
dynamicVar = "Hello, World!";

8. Implicitly Typed Variables (var)

Scope: Implicitly typed variables are declared using the var keyword. The type is inferred by the compiler based on the assigned value.

Lifetime: They exist for the scope in which they are declared.

Initialization: They must be initialized at the time of declaration.

var implicitVar = 80; // inferred as int