What is Memory Management?

Memory management is a core functionality of the .NET CLR, ensuring efficient memory usage by handling allocation and deallocation automatically. This prevents memory leaks, dangling pointers, and manual cleanup errors.

• ✔ Objects are created efficiently
• ✔ Memory is allocated and freed automatically
• ✔ Prevents memory leaks and dangling pointers

What is an Exception?

An exception is an error that disrupts the normal flow of execution. Examples include:

• ❌ Dividing a number by zero
• ❌ Opening a file that doesn’t exist
• ❌ Accessing a null object

In .NET, all exceptions are objects based on the System.Exception class. The CLR (Common Language Runtime) throws exceptions, and if not handled, the program crashes.

Why Do We Need Exception Handling?

Without exception handling, unexpected errors halt the application. Proper handling ensures:

• ✅ Errors are caught and handled
• ✅ Users see friendly messages instead of system crashes
• ✅ Resources (files, memory, connections) are released safely
• ✅ Application can continue running or shut down gracefully
• ✅ Errors are logged for debugging

Basic Structure of Exception Handling

Exception handling in C# uses the try, catch, finally, and throw keywords:

▶ try Block

try
{
    int result = 10 / 0;
}

▶ catch Block

catch (DivideByZeroException ex)
{
    Console.WriteLine("Cannot divide by zero.");
}

▶ finally Block

finally
{
    Console.WriteLine("Cleanup done.");
}

▶ throw Statement

throw new FileNotFoundException("File not found");

What is a Thread?

A thread is the smallest unit of execution within a process. Every .NET app starts with a main thread, and additional threads can be created for background tasks. Each thread has:

• 🧮 Its own stack, program counter, and local variables
• 🤝 Shared memory space with other threads in the same process

Creating Threads in .NET

Threads can be created using multiple approaches:

• Thread Class (Manual Threading)

Thread thread = new Thread(MyMethod);
thread.Start();
void MyMethod()
{
    Console.WriteLine("Running on separate thread.");
}

• ThreadPool (Efficient Thread Reuse)

ThreadPool.QueueUserWorkItem(state => {
    Console.WriteLine("Thread from ThreadPool");
});

• Task & async/await (Modern & Recommended)

await Task.Run(() => {
    Console.WriteLine("Task running asynchronously.");
});

Thread Lifecycle

A thread passes through several states during its lifetime:

1. 🔵 Unstarted – Created but not started
2. 🟢 Running – Actively executing
3. ⏸️ WaitSleepJoin – Paused/waiting
4. 🛑 Suspended – Deprecated state
5. ❌ Aborted – Forcefully terminated (not recommended)
6. ⚪ Stopped – Finished execution

Where Does JIT Fit in the .NET Execution Pipeline?

1. 👨‍💻 Developer writes C# code
2. ⚙️ C# Compiler (csc.exe) compiles it to IL + metadata → .dll or .exe
3. 📥 CLR loads the IL at runtime
4. 🚀 JIT compiler converts IL to native machine code (method-by-method)
5. 💻 CPU executes the native code

JIT vs AOT (Ahead-of-Time)