# מבוא ל-C# ו-.NET📖 שיעור

## מה זה?

מחשב לא מבין קובץ `.cs` ישירות — הוא מבין רק הוראות מעבד ברמת ה-0/1. C# פותרת את זה בשני שלבים: קודם קומפיילר (`csc`) הופך את הקוד למעין "שפת ביניים" בשם IL (Intermediate Language), ואז ה-CLR (Common Language Runtime) — סביבת הריצה של .NET — מריץ את ה-IL בפועל, ומתרגם אותו לקוד מכונה אמיתי תוך כדי ריצה (JIT — Just-In-Time compilation). זה בדיוק ההבדל בין "לכתוב קוד" ל"להריץ קוד".

## מילות מפתח שחשוב לזכור

• Compilation — תהליך הפיכת קוד המקור (`.cs`) לקוד ביניים שאפשר להריץ

• IL (Intermediate Language) — קוד הביניים שהקומפיילר מייצר; לא תלוי במעבד ספציפי

• CLR (Common Language Runtime) — סביבת הריצה של .NET שמריצה IL בפועל, כולל JIT ו-Garbage Collector

• .NET CLI — כלי שורת פקודה (`dotnet`) ליצירה, הרצה ובנייה של פרויקטים

• `Main` — מתודת הכניסה של כל תוכנית קונסולה ב-C#; שם ההרצה מתחילה

```csharp
// Program.cs — entry point of every console program
Console.WriteLine("Hello, C#!");
```

```bash
# .NET CLI — create, run and build
dotnet new console -o MyApp   # Creates a new console project in the MyApp folder
dotnet run                    # Compiles and runs in a single command
dotnet build                  # Only compiles, without running
```

```mermaid
flowchart RL
    A["Program.cs<br/>source code"] -->|"dotnet build<br/>compilation"| B["IL<br/>intermediate code"]
    B -->|"dotnet run<br/>CLR + JIT"| C["Machine code<br/>runs in practice"]
```

## הסבר עיקרי

למה יש שני שלבים ולא אחד — קומפילציה ישירה לקוד מכונה הייתה אומרת שכל תוכנית תלויה במעבד/מערכת הפעלה הספציפיים שעליהם קומפילו אותה. IL הוא שכבת-ביניים נייטרלית: אותו IL רץ על Windows, Linux או Mac, כי ה-CLR של כל מערכת יודע לתרגם אותו לקוד מכונה מקומי ברגע ההרצה (JIT). זו הסיבה ש-.NET מתואר כ"cross-platform".

`dotnet run` מסתיר שני שלבים — כשמריצים `dotnet run`, בפועל קורים שני דברים ברצף: קודם `dotnet build` (קומפילציה ל-IL), ואז הפעלת ה-CLR שמריץ את התוצאה. בזמן פיתוח נוח להשתמש ב-`dotnet run`; כשרוצים רק לוודא שהקוד מתקמפל בלי להריץ (למשל ב-CI), משתמשים ב-`dotnet build` לבד.

`Main` הוא תמיד נקודת ההתחלה — בפרויקט קונסולה, ה-CLR תמיד מתחיל להריץ מהמתודה `Main` (או, בגרסאות מודרניות של C#, מהשורה הראשונה של הקובץ הראשי — "Top-level statements", כמו בדוגמה למעלה). זה שקול מבחינה תפקודית ל-`function main()` בשפות אחרות.

## יתרונות

הפרדת קומפילציה מהרצה מאפשרת תוכנית אחת לרוץ על כמה מערכות הפעלה בלי לקמפל מחדש עבור כל אחת; ה-CLR מוסיף ניהול זיכרון אוטומטי (Garbage Collector) שחוסך באגים נפוצים של דליפות זיכרון; ה-CLI מספק זרימת עבודה אחידה (`new`/`run`/`build`) שעובדת זהה בכל מערכת הפעלה.

## חסרונות

שכבת ה-JIT מוסיפה עלות ריצה קלה בהשוואה לשפות שמקמפלות ישירות לקוד מכונה (כמו C++); שגיאות קומפילציה מתגלות רק כשמריצים `dotnet build`/`run`, לא תוך כדי כתיבה בעורך טקסט פשוט בלי IDE.

## נקודות חשובות

• C# עוברת שני שלבים: קומפילציה ל-IL, ואז הרצה על ה-CLR עם JIT

• ה-CLR הוא מה שהופך .NET ל-cross-platform — אותו IL רץ בכל מערכת הפעלה שיש לה CLR

• `dotnet run` = `dotnet build` + הרצה, ברצף אחד

• `Main` (או Top-level statements) היא תמיד נקודת הכניסה של תוכנית קונסולה

## טעויות נפוצות

• לבלבל בין "קוד המקור" (`.cs`) ל"קוד שרץ בפועל" (IL, שרק ה-CLR יודע להריץ)

• לחשוב ש-`dotnet run` "רק מריץ" — בפועל הוא גם מקמפל מחדש אם יש שינויים

• לשכוח ש-`dotnet build` בלבד לא מריץ כלום — רק בודק שהקוד תקין ומקמפל

## סיכום

C# עוברת קומפילציה לקוד ביניים (IL) שה-CLR מריץ בפועל בזמן ריצה עם JIT — זו הסיבה שאותו קוד רץ בלי שינוי על Windows, Linux ו-Mac. .NET CLI (`dotnet new`/`run`/`build`) הוא הכלי שמנהל את כל התהליך הזה משורת הפקודה, ו-`Main` (או Top-level statements) הוא תמיד נקודת ההתחלה של כל תוכנית.

## דוקומנטציה רשמית

[Microsoft Learn — .NET CLI overview](https://learn.microsoft.com/dotnet/core/tools/)

[Microsoft Learn — Common Language Runtime (CLR)](https://learn.microsoft.com/dotnet/standard/clr)

---

## תרגילים

### תרגיל 1 — יצירה והרצה ראשונה

**המשימה:** צרו פרויקט קונסולה חדש בשם `HelloCSharp` עם `dotnet new console`, שנו את השורה היחידה בקובץ כך שתדפיס את שמכם, והריצו עם `dotnet run`.

**בדיקה:** הפקודה `dotnet run` מדפיסה את שמכם לקונסולה בלי שגיאות.

### תרגיל 2 — build מול run

**המשימה:** הריצו `dotnet build` בלבד (בלי `run`) על הפרויקט מתרגיל 1, ובדקו מה נוצר בתיקיית `bin/`.

**בדיקה:** אתם רואים קובץ `.dll` שנוצר בתיקיית `bin/Debug/`, אבל שום דבר לא הודפס לקונסולה — כי `build` מקמפל בלבד, לא מריץ.

---

## פרויקט מסכם

**המשימה:** צרו תוכנית קונסולה שמדפיסה 3 שורות מידע על עצמה: שם התוכנית, גרסת .NET שמותקנת אצלכם (`dotnet --version`), ומשפט "התוכנית רצה בהצלחה".

**דרישות:**
1. שימוש ב-`dotnet new console` ליצירת הפרויקט
2. לפחות 3 קריאות נפרדות ל-`Console.WriteLine`
3. הרצה מוצלחת עם `dotnet run` ללא שגיאות קומפילציה

**בדיקה:** הרצת `dotnet run` מדפיסה את שלוש השורות בסדר הנכון, בלי אזהרות או שגיאות קומפילציה בפלט.

## מה בפרק הבא

בפרק הבא — **משתנים וטיפוסים**: איך שומרים ערכים בזיכרון, ולמה C# בודקת את סוג הערך כבר בזמן קומפילציה (Strong Static Typing) ולא מחכה לזמן ריצה כמו שפות דינמיות.