Variables in C#

What is a Variable?

A variable is a named storage location in memory that holds a value. In C#, every variable has a specific data type that determines:

• What kind of value it can store
• How much memory it occupies
• What operations can be performed on it

Memory and Variables

When you declare a variable in C#, you're essentially asking the computer to reserve a specific amount of memory space to store a value. The amount of memory reserved depends on the data type:

// This reserves 4 bytes of memory (for int)
int age = 25;

// This reserves 8 bytes of memory (for double)
double salary = 50000.50;

// This reserves memory for a reference (typically 8 bytes on 64-bit systems)
// plus the actual string data
string name = "John";

Variable Characteristics

1. Name (Identifier)

• Must start with a letter or underscore
• Can contain letters, digits, and underscores
• Case-sensitive
• Cannot be a C# keyword

// Valid variable names
int age;
string firstName;
double _salary;
int studentCount123;

// Invalid variable names
int 123age;        // Cannot start with digit
string class;      // 'class' is a keyword
int my-age;        // Hyphen not allowed

2. Data Type

• Determines the kind of data the variable can hold
• Affects memory allocation and operations
• Cannot be changed after declaration

3. Value

• The actual data stored in the variable
• Must match the variable's data type
• Can be changed during program execution

4. Scope

• The region of code where the variable is accessible
• Determined by where it's declared

Variable Lifetime

Variables have different lifetimes depending on where they're declared:

Local Variables

• Declared inside methods, constructors, or blocks
• Created when the block is entered
• Destroyed when the block is exited

public void CalculateTotal()
{
    int sum = 0;  // Created when method starts
    // ... use sum ...
} // sum is destroyed here

Instance Variables (Fields)

• Declared in a class but outside methods
• Created when the object is instantiated
• Exist as long as the object exists

public class Product
{
    private string name;     // Instance variable
    private decimal price;   // Instance variable

    public Product(string productName, decimal productPrice)
    {
        name = productName;
        price = productPrice;
    }
}

Static Variables

• Declared with the static keyword
• Shared among all instances of the class
• Exist for the entire program lifetime

public class Counter
{
    private static int instanceCount = 0;  // Static variable

    public Counter()
    {
        instanceCount++;  // Increments for every new instance
    }
}

Constants vs Variables

While variables can change their values, constants cannot:

// Variable - value can change
int score = 100;
score = 150;  // OK

// Constant - value cannot change
const double PI = 3.14159;
// PI = 3.14;  // Compilation error

Best Practices for Variable Naming

Naming Conventions

• Use camelCase for local variables and parameters
• Use PascalCase for properties and methods
• Use meaningful names that describe the purpose

// Good naming
int studentAge;
string customerName;
decimal accountBalance;
bool isActive;

// Avoid generic names
int x;           // What does x represent?
string str;      // Too vague
decimal d;       // Unclear purpose

Hungarian Notation (Avoid)

// Don't do this (Hungarian notation)
int iAge;        // 'i' for integer
string strName;  // 'str' for string

// Do this instead
int age;
string name;

Variable Initialization

Default Values

C# assigns default values to variables if not explicitly initialized:

int number;      // Default: 0
bool flag;       // Default: false
string text;     // Default: null
double value;    // Default: 0.0

Explicit Initialization

Always initialize variables to avoid unexpected behavior:

// Good practice
int age = 0;
string name = string.Empty;
bool isValid = false;

// Avoid
int age;  // Uninitialized - could cause issues

Common Variable-Related Errors

1. Use of Unassigned Local Variable

int number;
Console.WriteLine(number);  // Error: Use of unassigned local variable

2. Type Mismatch

int age = "25";  // Error: Cannot implicitly convert string to int

3. Scope Issues

if (true)
{
    int x = 10;
}
Console.WriteLine(x);  // Error: x is not in scope

Variable Declaration Patterns

Single Declaration

int age = 25;

Multiple Declarations

int x = 1, y = 2, z = 3;

Declaration without Initialization

int age;
age = 25;  // Initialize later

Inline Declaration (C# 7.0+)

// Before C# 7.0
int result;
if (int.TryParse(input, out result))
{
    // use result
}

// C# 7.0+
if (int.TryParse(input, out int result))
{
    // use result
}

Summary

Variables are the building blocks of any C# program. Understanding how they work in memory, their scope, lifetime, and proper naming conventions is crucial for writing maintainable and bug-free code. Always choose appropriate data types, initialize variables properly, and follow naming conventions to make your code readable and professional.