Variables and Data Types

Common Data Types

In C#, each variable must have a data type. The type tells the computer:

• What kind of data the variable can store
• How much memory to reserve
• What operations you can perform on it

Value Types (Store actual data)

Reference Types (Store a reference to data)

// ===== VALUE TYPE EXAMPLES =====
int age = 25;                    // Whole number
double price = 19.99;            // Decimal number
bool isActive = true;            // True or false
char grade = 'A';                // Single character
decimal salary = 50000.50m;    // High precision (money)

// ===== REFERENCE TYPE EXAMPLES =====
string name = "John Doe";        // Text
int[] numbers = { 1, 2, 3 };    // Array of numbers
DateTime today = DateTime.Now;   // Current date and time
object something = 42;           // Can hold anything

Declaring Variables

To create a variable, you need to tell C#: What type of data it will hold, what name to give it, and optionally what value to put in it.

Explicit Typing (Tell C# the type)

You specify the type directly. This is clear and explicit.

// Explicit typing - you tell C# the type
int count = 10;                    // count is an integer
string message = "Hello";          // message is a string
double pi = 3.14159;              // pi is a double
bool isReady = false;             // isReady is a bool

Implicit Typing (Let C# figure it out)

Use var and let C# figure out the type based on the value you assign. This is shorter and cleaner when the type is obvious.

// Implicit typing - C# figures out the type
var number = 42;        // C# knows this is an int
var text = "Hello";     // C# knows this is a string
var isReady = false;    // C# knows this is a bool
var price = 19.99;     // C# knows this is a double

Naming Rules

Variable names must follow these rules:

// ===== GOOD NAMES =====
string studentName = "Alice";
int studentAge = 20;
bool isEnrolled = true;
decimal monthlyFee = 150.50m;

// ===== BAD NAMES =====
// int 1stName = 10;    // ERROR: starts with number
// string my name = "John"; // ERROR: has a space
// string @name = "John"; // ERROR: has special character
// int x = 10;           // BAD: not descriptive

Constants

A constant is a variable whose value cannot change once you set it. Use const for values that never change.

// Constants - values that never change
const double Pi = 3.14159;        // Pi never changes
const int MaxValue = 100;          // Maximum allowed
const string AppName = "MyApp";     // Application name

// You CANNOT change a constant
// Pi = 3.14; // ERROR: Cannot assign to a constant

Nullable Types

By default, value types (like int, bool) cannot be null. But sometimes you need to represent "no value". That's where nullable types come in.

// Nullable types - can hold null
int? age = null;           // Age is unknown
bool? isMember = null;     // Membership status unknown

// Check if it has a value
if (age.HasValue)
{
    Console.WriteLine($"Age: {age.Value}");
}
else
{
    Console.WriteLine("Age not provided");
}

// Using the null-coalescing operator
int actualAge = age ?? 0;  // If age is null, use 0

Type Conversions

Sometimes you need to convert data from one type to another.

// ===== IMPLICIT CONVERSION (Automatic) =====
int num = 10;
double numDouble = num;  // Works automatically

// ===== EXPLICIT CONVERSION (Cast) =====
double pi = 3.14;
int piInt = (int)pi;  // piInt = 3 (loses decimal part)

// ===== USING CONVERT CLASS =====
string numberString = "123";
int number = Convert.ToInt32(numberString);

// ===== PARSING =====
string input = "456";
int parsedNumber = int.Parse(input);

// ===== SAFE PARSING =====
if (int.TryParse(input, out int result))
{
    Console.WriteLine($"Parsed successfully: {result}");
}
else
{
    Console.WriteLine("Invalid number");
}

Practical Examples

Quick Reference Table