C# & .NET 8 పరిచయం, ఆర్కిటెక్చర్ & డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్

1 C# భాష పుట్టుక, చరిత్ర & Anders Hejlsberg విజన్

1990ల చివరలో మైక్రోసాఫ్ట్ సంస్థ ఒక సరికొత్త, నెక్స్ట్-జనరేషన్ ఆబ్జెక్ట్-ఓరియెంటెడ్ భాషను రూపొందించాలని సంకల్పించింది. ఈ ప్రాజెక్ట్‌కు ప్రారంభంలో "COOL" (C-like Object Oriented Language) అని కోడ్‌నేమ్ పెట్టారు. ఈ భాష రూపకల్పన బాధ్యతను సాఫ్ట్‌వేర్ రంగంలో దిగ్గజ ఇంజనీర్ అయిన ఆండర్స్ హెల్స్‌బర్గ్ (Anders Hejlsberg) కు అప్పగించారు.

ఆండర్స్ హెల్స్‌బర్గ్ సామాన్యమైన వ్యక్తి కాదు—ఆయన గతంలో పాపులర్ అయిన Turbo Pascal మరియు Delphi లను రూపొందించారు, తర్వాతి కాలంలో ప్రపంచాన్ని శాసిస్తున్న TypeScript ను కూడా మైక్రోసాఫ్ట్‌లో ఆయనే సృష్టించారు! ఆయన ఆలోచనల ఫలితంగా 2000 సంవత్సరంలో అధికారికంగా C# (C-Sharp) ప్రకటించబడింది మరియు 2002 లో .NET Framework 1.0 తో పాటు విడుదలైంది.

'C#' అనే పేరు వెనుక ఉన్న మ్యూజికల్ రహస్యం:

సంగీత శాస్త్రంలో 'C' నోట్ పక్కన '♯' (Sharp) గుర్తు పెడితే, అది సాధారణ C కంటే ఒక సెమిటోన్ ఎక్కువ శృతిలో (Higher Pitch) మరింత శ్రావ్యంగా పలికిస్తుందని అర్థం. అలాగే ప్రోగ్రామింగ్ ప్రపంచంలో C మరియు C++ భాషల కంటే ఒక స్థాయి ఉన్నతమైనది, మరింత శక్తివంతమైనది అని తెలియజేయడానికి ఈ భాషకు C# అని నామకరణం చేశారు. అంతేకాకుండా, C++ లోని నాలుగు '+' గుర్తులను ఒకచోట చేర్చితే '#' ఆకారం ఏర్పడుతుంది (C++ ++ = C#)!

C# వెర్షన్ల పరిణామ క్రమం (Evolution Timeline):

2 .NET ఎకోసిస్టమ్ ఆర్కిటెక్చర్: .NET Framework vs .NET Core vs .NET 8+

చాలామంది బిగినర్లు "C# వేరు, .NET వేరు ఎలా?" అని అయోమయానికి గురవుతారు. స్పష్టంగా చెప్పాలంటే: C# అనేది ఒక ప్రోగ్రామింగ్ లాంగ్వేజ్ (మనం కోడ్ రాసే భాష), కాగా .NET అనేది ఒక రన్‌టైమ్ ప్లాట్‌ఫారమ్ మరియు భారీ లైబ్రరీల సముదాయం (ఆ కోడ్‌ను రన్ చేసే ఇంజిన్).

.NET పరిణామంలో 3 ప్రధాన యుగాలు:

• యుగం 1 (.NET Framework 2002 - 2019): ఇది కేవలం విండోస్ (Windows OS) ఆపరేటింగ్ సిస్టమ్‌లో మాత్రమే పనిచేసేది. భారీ సైజు, విండోస్ డిపెండెన్సీ ఉండేది. ప్రస్తుతం ఇది కేవలం మెయింటెనెన్స్ మోడ్‌లో ఉంది.
• యుగం 2 (.NET Core 2016 - 2020): మైక్రోసాఫ్ట్ ఓపెన్ సోర్స్ విధానాన్ని స్వీకరించి, మొత్తం ఆర్కిటెక్చర్‌ను స్క్రాచ్ నుండి తిరగరాసింది. ఇది విండోస్, లైనక్స్, మరియు మ్యాక్ (macOS) లపై తేలికపాటిగా పనిచేసే క్రాస్-ప్లాట్‌ఫారమ్ ఇంజిన్‌గా అవతరించింది.
• యుగం 3 (.NET 5 / 6 / 7 / 8 / 9 Unified Era): 'Core' మరియు 'Framework' అనే గందరగోళాన్ని పూర్తిగా తొలగించి, వాటన్నింటినీ ఒకే ఒక్క Modern .NET కిందకు తీసుకువచ్చారు. వెబ్, క్లౌడ్, డెస్క్‌టాప్, మొబైల్ మరియు IoT అన్నీ ఒకే .NET SDK తో నిర్మించవచ్చు!

3 కంప్యూటర్ మెమరీ & ఎగ్జిక్యూషన్ పైప్‌లైన్: C# కోడ్ ఎలా రన్ అవుతుంది?

C భాష నేరుగా మెషిన్ కోడ్‌గా కంపైల్ అవుతుంది, పైథాన్ ఇంటర్‌ప్రిటర్‌తో లైన్ బై లైన్ రన్ అవుతుంది. కానీ C# ఒక అద్భుతమైన టూ-స్టేజ్ హైబ్రిడ్ కంపైలేషన్ (Two-Stage Compilation Pipeline) విధానాన్ని ఉపయోగిస్తుంది. ఇది ప్లాట్‌ఫారమ్ ఇండిపెండెన్స్‌ను మరియు అత్యధిక ప్రాసెసింగ్ వేగాన్ని రెండింటినీ అందిస్తుంది.

స్టేజ్ 1: డెవలప్‌మెంట్ టైమ్ (Roslyn C# Compiler - csc)

మనం రాసిన C# సోర్స్ కోడ్ (.cs ఫైల్స్) ను మైక్రోసాఫ్ట్ యొక్క ఆధునిక ఓపెన్ సోర్స్ కంపైలర్ Roslyn కంపైల్ చేస్తుంది. అయితే ఇది నేరుగా CPU కి అర్థమయ్యే మెషిన్ కోడ్‌గా మార్చదు! బదులుగా ఇది CIL / IL (Common Intermediate Language) అనే మధ్యంతర బైనరీ బైట్‌కోడ్‌గా మార్చి, మెటాడేటాతో కలిపి .dll లేదా .exe అసెంబ్లీలుగా భద్రపరుస్తుంది.

స్టేజ్ 2: రన్‌టైమ్ (Common Language Runtime - CLR & RyuJIT Compiler)

యూజర్ ప్రోగ్రామ్‌ను రన్ చేసినప్పుడు, CLR (Common Language Runtime) రంగంలోకి దిగుతుంది. CLR లోపల ఉండే RyuJIT (Just-In-Time) Compiler ఆ IL కోడ్‌ను చదివి, ఆ సమయంలో మీ కంప్యూటర్‌లో ఉన్న CPU ఆర్కిటెక్చర్ (Intel x64, AMD64, లేదా Apple Silicon ARM64) కి సరిపోయే అల్ట్రా-ఫాస్ట్ నేటివ్ మెషిన్ కోడ్ (Native Machine Instructions) గా అక్కడికక్కడే మార్చి ఎగ్జిక్యూట్ చేస్తుంది!

విజువల్ ఎగ్జిక్యూషన్ పైప్‌లైన్ ఆర్కిటెక్చర్ డయాగ్రమ్:

4 CLR (Common Language Runtime) యొక్క 4 సూపర్ పవర్స్

C# కోడ్‌ను మేనేజ్డ్ కోడ్ (Managed Code) అంటారు. ఎందుకంటే ఈ కోడ్ నేరుగా ఆపరేటింగ్ సిస్టమ్‌పై నిర్లక్ష్యంగా పరిగెత్తదు; ఇది CLR అనే ఒక నిపుణులైన వర్చువల్ గార్డియన్ పర్యవేక్షణలో పనిచేస్తుంది. CLR అందించే 4 అద్భుతమైన సేవలు:

5 డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్ సెటప్: .NET 8 SDK & VS Code

C# ప్రోగ్రామింగ్ ప్రారంభించడానికి మీ కంప్యూటర్‌లో ప్రధానంగా రెండు సాఫ్ట్‌వేర్లు ఉండాలి:

1. .NET 8 SDK (Software Development Kit): ఇందులో C# కంపైలర్ (Roslyn), రన్‌టైమ్ ఇంజిన్ (CLR), మరియు కమాండ్ లైన్ టూల్స్ ఉంటాయి.
2. కోడ్ ఎడిటర్ (IDE): Visual Studio Code (ఉచితం & లైట్‌వెయిట్) లేదా Visual Studio 2022 Community ఎడిషన్.

SDK vs Runtime తేడా:

• .NET Runtime: కేవలం ఇప్పటికే కంపైల్ చేయబడిన C# యాప్‌లను రన్ చేయడానికి మాత్రమే సరిపోతుంది (ఎండ్యూజర్లకు ఇది చాలు).
• .NET SDK: ఇందులో రన్‌టైమ్‌తో పాటు కొత్తగా కోడ్ రాయడానికి, కంపైల్ చేయడానికి మరియు బిల్డ్ చేయడానికి అవసరమైన అన్ని టూల్స్ ఉంటాయి (డెవలపర్లకు ఇది తప్పనిసరి).

స్టెప్ బై స్టెప్ ఇన్‌స్టాలేషన్ గైడ్:

6 .NET CLI (Command-Line Interface) ప్రాథమిక కమాండ్స్

ఆధునిక సాఫ్ట్‌వేర్ ఇంజనీర్లు మరియు డెవలప్‌మెంట్ పైప్‌లైన్లు (CI/CD) గ్రాఫికల్ బటన్ల కంటే .NET CLI (Command-Line Interface) టూల్స్‌పైనే ఎక్కువగా ఆధారపడతారు. మీరు తెలుసుకోవాల్సిన అత్యంత కీలకమైన CLI కమాండ్స్ ఇక్కడ ఉన్నాయి:

7 ప్రాజెక్ట్ ఫైల్ స్ట్రక్చర్ అనాటమీ (.csproj, bin, obj, Program.cs)

మనం dotnet new console -o HelloCSharp అని టైప్ చేయగానే ఆ ఫోల్డర్‌లో క్రింది ఫైల్స్ సృష్టించబడతాయి:

1. HelloCSharp.csproj ఫైల్ అంతర్గత స్వరూపం:

ఇది MSBuild ఇంజిన్‌కు మన ప్రాజెక్ట్ గురించి తెలిపే కాన్ఫిగరేషన్ ఫైల్:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <!-- కన్సోల్ అప్లికేషన్ అని నిర్ధారించడం -->
    <OutputType>Exe</OutputType>
    
    <!-- .NET 8 LTS టార్గెట్ ఫ్రేమ్‌వర్క్ -->
    <TargetFramework>net8.0</TargetFramework>
    
    <!-- System నేమ్‌స్పేస్‌ను ఆటోమేటిక్‌గా ఇంక్లూడ్ చేసే ఆధునిక C# ఫీచర్ -->
    <ImplicitUsings>enable</ImplicitUsings>
    
    <!-- నల్ పాయింటర్ ఎర్రర్లను నివారించే స్ట్రిక్ట్ టైప్ చెకింగ్ -->
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>

8 మొదటి C# ప్రోగ్రామ్: క్లాసిక్ vs మోడ్రన్ Top-Level Statements

C# భాష ప్రారంభం నుండి C# 8 వరకు ప్రతి చిన్న కోడ్ ముక్క రాయాలన్నా ఒక క్లాస్ మరియు ఒక స్టాటిక్ Main() మెథడ్ తప్పనిసరిగా ఉండేది. కానీ C# 9 నుండి మైక్రోసాఫ్ట్ టాప్-లెవల్ స్టేట్‌మెంట్స్ (Top-Level Statements) అనే అద్భుతమైన ఫీచర్‌ను పరిచయం చేసింది.

క్లాసిక్ విధానం (Traditional C# with Boilerplate):

using System;

namespace MyFirstApp
{
    internal class Program
    {
        // ప్రోగ్రామ్ ఎగ్జిక్యూషన్ ఇక్కడే ప్రారంభమవుతుంది
        static void Main(string[] args)
        {
            Console.WriteLine("నమస్కారం ప్రపంచం! ఇది క్లాసిక్ C# శైలి.");
        }
    }
}

క్లాసిక్ కోడ్ భాగాల సమగ్ర విశ్లేషణ:

• using System; — బేసిక్ డేటా టైప్స్ మరియు Console క్లాస్ ఉన్న ప్రధాన నేమ్‌స్పేస్‌ను దిగుమతి చేసుకుంటుంది.
• namespace MyFirstApp — సంబంధిత క్లాసులను ఒక గ్రూప్‌గా నిర్వహించే ఒక లాజికల్ కంటైనర్ (పేర్ల వైరుధ్యం రాకుండా చూస్తుంది).
• class Program — C# లో ప్రతి ఫంక్షన్ మరియు వేరియబుల్ ఖచ్చితంగా ఏదో ఒక క్లాస్ లోపలే ఉండాలి (Pure Object-Oriented).
• static void Main(string[] args) — OS ప్రోగ్రామ్‌ను రన్ చేసే అధికారిక ప్రారంభ ద్వారం (Entry Point). static అంటే ఆబ్జెక్ట్ సృష్టించకుండానే రన్ అవ్వగలదు; void అంటే ఏ విలువను రిటర్న్ చేయదు; string[] args కమాండ్ లైన్ ఆర్గ్యుమెంట్లను తీసుకుంటుంది.

మోడ్రన్ శైలి (Modern C# 12 Top-Level Statements):

ఆధునిక C# లో ఈ అనవసరమైన బోయిలర్‌ప్లేట్ మొత్తం రాయాల్సిన పనిలేదు! Program.cs ఫైల్‌లో నేరుగా ఒకే లైన్ రాయవచ్చు:

// .NET 8 లో సింగిల్ లైన్ టాప్-లెవల్ కోడ్
Console.WriteLine("నమస్కారం! ఇది సరికొత్త మోడ్రన్ C# 12.");

9 Console క్లాస్ & బేసిక్ I/O మెకానిక్స్

కన్సోల్ టెర్మినల్‌తో మాట్లాడటానికి C# లో System.Console అనే స్టాటిక్ క్లాస్‌ను ఉపయోగిస్తాం. ఇందులో ముఖ్యమైన మెథడ్స్ మరియు ఫీచర్లు:

• Console.WriteLine("టెక్స్ట్") — టెక్స్ట్‌ను ప్రింట్ చేసి కర్సర్‌ను తదుపరి లైన్‌కు (Newline) తీసుకెళ్తుంది.
• Console.Write("టెక్స్ట్") — టెక్స్ట్‌ను ప్రింట్ చేస్తుంది కానీ అదే లైన్‌లో కర్సర్‌ను ఉంచుతుంది.
• Console.ReadLine() — యూజర్ కీబోర్డ్ ద్వారా ఎంటర్ చేసిన పూర్తి వాక్యాన్ని string రూపంలో రీడ్ చేస్తుంది.

ప్రాక్టికల్ డెమో: స్ట్రింగ్ ఇంటర్‌పోలేషన్ ($) మరియు కలర్ టెర్మినల్ అవుట్‌పుట్

using System;

// టెర్మినల్ టైటిల్ మరియు రంగులు సెట్ చేయడం
Console.Title = "C# మాస్టర్‌క్లాస్ డెమో";
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("========================================");
Console.WriteLine("   🚀 C# & .NET 8 ఇంటరాక్టివ్ వెల్‌కమ్    ");
Console.WriteLine("========================================");
Console.ResetColor();

// యూజర్ ఇన్‌పుట్ స్వీకరించడం
Console.Write("మీ శుభనామం ఏమిటి? ");
string? userName = Console.ReadLine();

Console.Write("మీరు ఏ నగరంలో నివసిస్తున్నారు? ");
string? city = Console.ReadLine();

// మోడ్రన్ C# స్ట్రింగ్ ఇంటర్‌పోలేషన్ ($) వాడకం
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"\nహలో {userName}! {city} నగరానికి మా హృదయపూర్వక స్వాగతం!");
Console.WriteLine($"ప్రస్తుత సర్వర్ సమయం: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
Console.ResetColor();

Console.WriteLine("\nముగించడానికి ఏదైనా కీ ప్రెస్ చేయండి...");
Console.ReadKey();

10 C# కోడింగ్ కన్వెన్షన్స్ & Microsoft బెస్ట్ ప్రాక్టీసెస్

ప్రపంచవ్యాప్తంగా ప్రొఫెషనల్ C# కోడ్ బేస్‌లు మైక్రోసాఫ్ట్ నిర్దేశించిన ప్రామాణిక నామకరణ నిబంధనలను (Naming Conventions) ఖచ్చితంగా పాటిస్తాయి:

XML డాక్యుమెంటేషన్ కామెంట్స్ (XML Doc Comments):

C# లో సాధారణ // కామెంట్లతో పాటు మూడు స్లాష్‌లతో కూడిన /// కామెంట్లను వాడతారు. ఇది రాస్తే విజువల్ స్టూడియో మరియు ఇతర ఎడిటర్లు ఫంక్షన్లపై మౌస్ పెట్టినప్పుడు అందమైన హెల్ప్ బాక్సులను (IntelliSense Tooltips) చూపిస్తాయి!

/// <summary>
/// ఇచ్చిన రెండు సంఖ్యల మొత్తాన్ని లెక్కిస్తుంది.
/// </summary>
/// <param name="a">మొదటి పూర్ణాంకం</param>
/// <param name="b">రెండవ పూర్ణాంకం</param>
/// <returns>రెండు సంఖ్యల కూడిక ఫలితం</returns>
int AddNumbers(int a, int b)
{
    return a + b;
}

11 ప్రాక్టికల్ ప్రాజెక్ట్: ఇంటరాక్టివ్ .NET సిస్టమ్ ఇన్ఫర్మేషన్ CLI టూల్

మనం నేర్చుకున్న C# & .NET పరిజ్ఞానంతో మన కంప్యూటర్ హార్డ్‌వేర్, ఆపరేటింగ్ సిస్టమ్, మెమరీ మరియు .NET రన్‌టైమ్ వివరాలను వెలికితీసే ఒక ప్రొడక్షన్-గ్రేడ్ సిస్టమ్ డయాగ్నోస్టిక్స్ CLI టూల్ (System Diagnostics Tool) ను నిర్మిద్దాం:

using System;

Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("================================================================");
Console.WriteLine("        💻 .NET 8 SYSTEM DIAGNOSTICS & RUNTIME AUDITOR           ");
Console.WriteLine("================================================================");
Console.ResetColor();

// Environment క్లాస్ ద్వారా సిస్టమ్ సమాచారాన్ని సేకరించడం
string osVersion = Environment.OSVersion.ToString();
string machineName = Environment.MachineName;
string userName = Environment.UserName;
int coreCount = Environment.ProcessorCount;
Version dotnetVersion = Environment.Version;
bool is64BitOS = Environment.Is64BitOperatingSystem;
bool is64BitProcess = Environment.Is64BitProcess;
long workingSetMemory = Environment.WorkingSet / (1024 * 1024); // MB లోకి మార్చడం
TimeSpan uptime = TimeSpan.FromMilliseconds(Environment.TickCount64);

Console.WriteLine($"
[1] హోస్ట్ మెషిన్ సమాచారం:");
Console.WriteLine($"    • కంప్యూటర్ పేరు      : {machineName}");
Console.WriteLine($"    • లాగిన్ యూజర్        : {userName}");
Console.WriteLine($"    • ఆపరేటింగ్ సిస్టమ్     : {osVersion} ({(is64BitOS ? "64-bit OS" : "32-bit OS")})");

Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"
[2] .NET రన్‌టైమ్ వివరాలు:");
Console.WriteLine($"    • .NET CLR వెర్షన్    : {dotnetVersion}");
Console.WriteLine($"    • ప్రాసెస్ ఆర్కిటెక్చర్ : {(is64BitProcess ? "x64 Managed Process" : "x86 Process")}");
Console.WriteLine($"    • GC అలోకేటెడ్ మెమరీ  : {workingSetMemory} MB");
Console.ResetColor();

Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"
[3] ప్రాసెసర్ & పనితీరు లెక్కలు:");
Console.WriteLine($"    • లభ్యమైన CPU కోర్లు   : {coreCount} Logical Cores");
Console.WriteLine($"    • సిస్టమ్ అప్‌టైమ్     : {uptime.Days} రోజుల {uptime.Hours} గంటల {uptime.Minutes} నిమిషాలు");
Console.WriteLine($"    • ప్రస్తుత ఫోల్డర్     : {Environment.CurrentDirectory}");
Console.ResetColor();

Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("
================================================================");
Console.WriteLine("✅ సిస్టమ్ ఆడిట్ విజయవంతంగా పూర్తయింది. .NET 8 రన్‌టైమ్ పర్ఫెక్ట్‌గా ఉంది!");
Console.WriteLine("================================================================");
Console.ResetColor();

12 కామన్ బిగినర్ ఎర్రర్స్ & ట్రబుల్‌షూటింగ్ గైడ్

C# ప్రారంభంలో విద్యార్థులు తరచుగా ఎదుర్కొనే 4 ప్రధాన సమస్యలు మరియు వాటిని పరిష్కరించే మార్గాలు:

13 సారాంశం, ఇంటర్వ్యూ ప్రశ్నలు & సెల్ఫ్-అసెస్మెంట్ క్విజ్

కీలక సారాంశం (Key Takeaways):

• C# & .NET: C# అనేది ఆధునిక, టైప్-సేఫ్ ఆబ్జెక్ట్-ఓరియెంటెడ్ భాష; .NET అనేది దానిని రన్ చేసే పవర్‌ఫుల్ ప్లాట్‌ఫారమ్.
• Two-Stage Compilation: Roslyn కంపైలర్ C# కోడ్‌ను IL (Intermediate Language) గా మారుస్తుంది; రన్‌టైమ్‌లో RyuJIT దానిని నేటివ్ మెషిన్ కోడ్‌గా ఎగ్జిక్యూట్ చేస్తుంది.
• CLR (Common Language Runtime): ఆటోమేటిక్ గార్బేజ్ కలెక్షన్, మెమరీ సేఫ్టీ, ఎక్సెప్షన్ హ్యాండ్లింగ్ అందించే ఇంజిన్.
• CLI Commands: dotnet new, dotnet build, dotnet run ప్రాజెక్ట్ లైఫ్‌సైకిల్‌ను శాసిస్తాయి.
• Top-Level Statements: మోడ్రన్ C# లో బోయిలర్‌ప్లేట్ లేకుండా డైరెక్ట్‌గా క్లీన్ కోడ్ రాయవచ్చు.

టాప్ 5 C# & .NET ఇంటర్వ్యూ ప్రశ్నలు:

1. Q1: మేనేజ్డ్ కోడ్ (Managed Code) మరియు అన్‌మేనేజ్డ్ కోడ్ (Unmanaged Code) మధ్య తేడా ఏమిటి?
   జవాబు: CLR వర్చువల్ మెషిన్ పర్యవేక్షణలో నడుస్తూ గార్బేజ్ కలెక్టర్ ద్వారా మెమరీ మేనేజ్ చేయబడే కోడ్‌ను మేనేజ్డ్ కోడ్ (C#, F#, VB.NET) అంటారు. నేరుగా ఆపరేటింగ్ సిస్టమ్ హార్డ్‌వేర్‌పై నడుస్తూ డెవలపరే మెమరీని ఫ్రీ చేయాల్సిన కోడ్‌ను అన్‌మేనేజ్డ్ కోడ్ (C, C++) అంటారు.
2. Q2: .NET లో IL (Intermediate Language) మరియు JIT కంపైలర్ పాత్ర ఏమిటి?
   జవాబు: C# కంపైలర్ కోడ్‌ను ప్రాసెసర్-స్వతంత్ర IL బైట్‌కోడ్‌గా మారుస్తుంది. ప్రోగ్రామ్ రన్ అయ్యే సమయంలో JIT (Just-In-Time) కంపైలర్ ఆ IL కోడ్‌ను ఆ కంప్యూటర్ CPU కి తగిన నేటివ్ మెషిన్ కోడ్‌గా క్షణాల్లో కంపైల్ చేస్తుంది.
3. Q3: .NET Framework మరియు ఆధునిక .NET 8 మధ్య ప్రధాన వ్యత్యాసాలు ఏమిటి?
   జవాబు: పాత .NET Framework కేవలం Windows లో మాత్రమే పనిచేసేది, ఓపెన్ సోర్స్ కాదు. మోడ్రన్ .NET 8 పూర్తిగా ఓపెన్ సోర్స్, క్లౌడ్-ఆప్టిమైజ్డ్, విండోస్/లైనక్స్/మ్యాక్‌లలో పనిచేసే క్రాస్-ప్లాట్‌ఫారమ్ హై-స్పీడ్ ఇంజిన్.
4. Q4: Top-Level Statements వాడటం వల్ల ఏవైనా పెర్ఫార్మెన్స్ సమస్యలు వస్తాయా?
   జవాబు: అస్సలు రావు! కంపైలేషన్ సమయంలో Roslyn కంపైలర్ దానిని సాధారణ Program.Main లాగే మారుస్తుంది కాబట్టి ఎగ్జిక్యూషన్ స్పీడ్‌లో ఎటువంటి తేడా ఉండదు.
5. Q5: Roslyn కంపైలర్ ప్రత్యేకత ఏమిటి?
   జవాబు: Roslyn అనేది C# లోనే తిరిగి వ్రాయబడిన మైక్రోసాఫ్ట్ ఓపెన్ సోర్స్ కంపైలర్ ప్లాట్‌ఫారమ్. ఇది కంపైలేషన్ చేయడమే కాకుండా, కోడ్ అనాలిసిస్, రిఫ్యాక్టరింగ్ మరియు IDE IntelliSense సేవలను ఓపెన్ API ల రూపంలో అందిస్తుంది.

ఇంటరాక్టివ్ సెల్ఫ్-అసెస్మెంట్ క్విజ్ (Self-Assessment Quiz):