.NET Framework: Architecture, CLR, BCL, and Applications

1. What is .NET Framework?

.NET Framework is a software development platform by Microsoft that provides:

• A runtime environment (CLR) to execute programs.
• A class library (BCL) for reusable code (e.g., file I/O, networking).
• Language interoperability (C#, VB.NET, F# can work together).
• Cross-platform support (via .NET Core and .NET 5+).

Key Components

2. How .NET Works: Compilation and Execution

.NET programs follow this workflow:

1. Source Code (e.g., Program.cs in C#) → Compiler → CIL (MSIL).
2. JIT Compiler converts CIL to machine code at runtime.
3. CLR executes the code, handles memory, and manages threads.

Visual: Compilation Process

flowchart LR
    A["Source Code<br/>(e.g., C#)"] -->|"Compiler"| B["CIL<br/>(MSIL)"]
    B -->|"JIT Compiler"| C["Machine Code"]
    C -->|"CLR"| D["Execution<br/>(Memory Management, Threads)"]

Example: A Simple C# Program

using System;
class Program {
    static void Main() {
        Console.WriteLine("Hello, .NET!");
    }
}

Trace:

3. CLR: The Engine Behind .NET

The CLR handles:

• Memory Management: Garbage Collection (GC) automatically frees unused objects.
• Security: Code Access Security (CAS) restricts unsafe operations.
• Threading: Manages multi-threaded applications.
• Exception Handling: Structured error handling via try-catch-finally.

Garbage Collection (GC) in Action

sequenceDiagram
    participant App as Application
    participant CLR as CLR
    participant GC as Garbage Collector
    App->>CLR: Allocates Object A
    App->>CLR: Loses Reference to A
    CLR->>GC: Request GC
    GC->>CLR: Frees Object A

Example: GC in C#

class Program {
    static void Main() {
        var obj = new Object(); // Allocated on heap
        obj = null;             // No references → GC target
        GC.Collect();           // Forces collection (rarely used)
    }
}

4. BCL: Reusable Libraries

The BCL provides classes for:

• File I/O: System.IO (e.g., File.ReadAllText()).
• Collections: List<T>, Dictionary<TKey, TValue>.
• Networking: System.Net (e.g., HTTP requests).
• Multithreading: System.Threading (e.g., Task).

Example: Reading a File (BCL in Action)

using System;
using System.IO;

class Program {
    static void Main() {
        string text = File.ReadAllText("example.txt");
        Console.WriteLine(text);
    }
}

Trace:

5. .NET Versions: Framework vs. Core vs. 5+

6. Real-World Applications in Nepal

1. eSewa (Digital Payments)

• Uses: .NET Core for backend APIs (e.g., transaction processing).
• How: CLR manages concurrent requests; BCL handles encryption (System.Security.Cryptography).

2. Khalti (Mobile Banking)

• Uses: .NET Framework for Windows-based admin dashboards.
• How: BCL’s System.Data connects to SQL Server for user data.

3. Daraz (E-Commerce)

• Uses: .NET 5+ for scalable web APIs.
• How: CLR’s garbage collection prevents memory leaks during high traffic.

4. NTC (Telecom Billing)

• Uses: .NET Framework for legacy billing systems.
• How: BCL’s System.Threading handles parallel call processing.

7. Advantages and Disadvantages of .NET

8. Exam Tip: What to Focus On

1. Architecture: Know CLR vs. BCL vs. FCL roles.
2. Compilation: Source → CIL → JIT → Execution.
3. GC: How memory is managed (e.g., GC.Collect()).
4. BCL Examples: System.IO, System.Collections.
5. Version Differences: When to use Framework vs. Core.
6. Real-World Links: Connect concepts to eSewa/Khalti/Daraz.

Common Exam Questions:

• "Explain the role of CLR in .NET."
• "How does garbage collection work in C#?"
• "Compare .NET Framework and .NET Core."

Summary Table for Quick Review