בחלק זה נלמד כיצד לעבוד עם משתנים (Variables) מטיפוסים בסיסיים.

פתחו את סביבת העבודה וצרו פרויקט חדש.

מה זה משתנה?

משתנה הוא איזור בזיכרון של המחשב שנתתם לו שם. בעזרת שם המשתנה ניתן לפנות לאזור הזיכרון ולכתוב שם ערכים או לקרוא משם ערכים. 
משתנים הם מרכיב חשוב ביותר בכל שפת תכנות. 
לכל משתנה יש שם וסוג (טיפוס), טיפוס המשתנה קובע את סוג הערכים שניתן להכניס לתוך המשתנה. 
הטיפוסים החשובים ביותר של משתנים הם: משתני אמת/שקר, מחרוזות, מספרים שלמים ומספרים שאינם שלמים. 

משתנים מטיפוס אמת/שקר (בוליאני)

משתנה מטיפוס אמת/שקר הוא משתנה שיכול להכיל רק את הערכים הבאים: true , false. 
בדרך כלל נשתמש במשתנה מסוג זה כאשר נרצה לזכור משהו שיש לו רק שתי אפשרויות.

לדוגמא, בקוד הבא אנו מגדירים משתנה מטיפוס אמת/שקר בעל השם hasJob, ומציבים בו את הערך true:

bool hasJob = true;

לחילופין יכולנו להציב את הערך false:

hasJob = false;

הערה: נשים לב שבדוגמא השניה לא ציינו את טיפוס המשתנה מאחר והמשתנה כבר הוגדר בשורה הקודמת.

חשוב לזכור שכל משתנה צריך להיות מוגדר עם סוג המשתנה רק בשימוש הראשון. 
בשימושים שיבואו לאחר מכן יש לציין רק את שם המשתנה.

משתנים מטיפוס מחרוזת

ישנם שני סוגים של משתנים מטיפוס מחרוזת.

הסוג הראשון נקרא char והוא מסוגל לשמור תו בודד כגון האות 'a' או הסימן '@'.

לדוגמא, בקוד הבא אנו מגדירים משתנה מטיפוס char ומציבים בו את האות 'a', ובשורה שלאחריו אנו מציבים בו את הסימן '@':

char myChar = 'a';
myChar = '@';

הסוג השני של משתנה מטיפוס מחרוזת נקרא string והוא מסוגל לשמור רצף כלשהו של תווים, כמו שם של אדם:

לדוגמא, בקוד הבא אנו מגדירים משתנה מטיפוס string ומציבים בו מחרוזת:

string myName = "Arik";

משתנים מטיפוס מספרים שלמים

ישנם מספר סוגים שונים של משתנים שיכולים להכיל מספרים שלמים. 
ההבדל בין הסוגים השונים הוא טווח המספרים שהם יכולים לקבל.

לדוגמא, משתנה מטיפוס byte יכול לקבל את כל הערכים בטווח 0 עד 255, לעומת זאת משתנה מטיפוס sbyte יכול לקבל את כל הערכים בטווח -128 עד 127. 
הסיבה שיש טיפוסים שונים בעלי טווחים שונים היא שמשתנה בעל טווח רחב יותר תופס יותר מקום בזיכרון (יותר ביטים).

להלן טבלה שמפרטת את סוגי המשתנים השונים והטווחים שלהם:

לרוב משתנים מטיפוס int מספיקים לנו ונשתמש בהם בדרך כלל ליצוג מספרים שלמים.

לדוגמא, בקוד הבא אנו מגדירים משתנה מטיפוס int ומציבים בו את המספר השלם 86400:

int secondsInDay = 86400;

משתנים מטיפוס מספרים לא שלמים

ישנם מספר סוגים שונים של משתנים שיכולים להכיל מספרים לא שאינם בהכרח שלמים. 
ההבדל בין הסוגים השונים הוא מספר הספרות שהם מסוגלים לשמור וכתוצאה מכך גם כמות הזכרון שהם דורשים. 
שימו לב, המספרים נשמרים מאחורי הקלעים בכתיב מדעי ולכן כאשר אנו אומרים שהדיוק הוא בן 7 ספרות הכוונה היא 7 ספרות בסך הכל, לפני ואחרי הנקודה העשרונית.

הסוגים השונים מפורטים בטבלה להלן:

לרוב כאשר נרצה לעבור עם מספרים לא שלמים נעבוד עם משתנים מטיפוס double.

לדוגמא, בקוד הבא אנו מגדירים משתנה מטיפוס double ומציבים בו את המספר 3.14159265 (ערך מקורב לקבועפאי):

 double pi = 3.1415926535;

לאחר שלמדנו על סוגי המשתנים הבסיסיים בחלק הקודם, בחלק זה נלמד על האופרטורים האריתמטיים שניתן להפעיל על משתנים מטיפוס מספר.

מה זה אופרטורים?

אופרטורים הם פעולות שניתן לעשות על משתנים, לרוב הן מיוצגות ע"י איזשהו סימן מיוחד, לדוגמא '+' הוא אופרטור שמחבר בין שני משתנים ומחזיר את תוצאת החיבור.

אופרטורים שעובדים על זוגות של מספרים

הסוג הכי מוכר של אופרטורים הוא כאלה שעובדים על שני מספרים ומחזירים מספר שלישי (המספרים יכולים להיות מטיפוסים שלמים או מטיפוסים לא שלמים). 
באופרטורים מסוג זה נמצא את: + , - , * , / , %

אופרטור '+' מחבר שני מספרים, לדוגמא הקוד הבא מחבר בין שני מספרים x ו y ושם את תוצאת החיבור במשתנה z:

int x = 5;
int y = 3;
int z;
 
z = x + y;

באופן דומה פועלים האופרטורים האחרים. 
אופרטור '-' מחסר שני מספרים. 
אופרטור '*' מכפיל שני מספרים.

אופרטור '/' מחלק בין שני מספרים, נעיר שתוצאת החלוקה תלויה בסוג המשתנים. 
אם נחלק שני מספרים מטיפוס double (שיכול להכיל מספרים לא שלמים) אזי התוצאה יכולה להיות מספר לא שלם.
לעומת זאת, אם נחלק שני מספרים מטיפוס int התוצאה תהיה בהכרח מספר שלם (בעצם נקבל את התוצאה מעוגלת כלפי מטה).

לדוגמא, בקוד הבא אנו מחשבים חלוקה של 5 ב 2 ומקבלים 2.5 כאשר משתמשים במשתנה מסוג double ואילו כאשר נשתמש במשתנה מסוג int נקבל 2:

double x = 5;
double y = 2;
double z = x / y; // z = 2.5
 
int a = 5;
int b = 2;
int c = a / b; // c = 2

הערה: החלקים בקוד הצבועים בירוק הם הערות. 
בדרך כלל משתמשים בהערות בקוד כדי לספק הסברים לקוד מסובך. 
הערה מתחילה בסימן // ונמשכת עד סוף השורה.

האופרטור '%' הוא אופרטור שעובד רק על מספרים שלמים ותפקידו להחזיר את שארית החלוקה. 
לדוגמא, בקוד הבא נחשב את שארית החלוקה של 5 ב 2 ונקבל בתור תוצאה 1:

int a = 5;
int b = 2;
int c = a % b; // c = 1

אופרטורי הוספה והפחתה

אופרטורים אלו עובדים על משתנה אחד מטיפוס שלם. 
האופרטור '++' מקדם את המשתנה ב1, ואילו האופרטור '--' מפחית את ערך המשתנה ב1.

לדוגמא, ערך המשתנה a לאחר השורה השניה הוא 10 ולאחר השורה הרביעית הוא 8:

int a = 9;
++a; // a = 10
--a; // a = 9
--a; // a = 8

אופרטורי הצבה אריתמטיים

אופרטורים אלו משמשים בעצם לכתיבה מקוצרת של האופרטורים האריתמטיים הרגילים. 
האופרטור '+=' מבצע חיבור והצבה באותה פעולה.

לדוגמא, בקוד הבא השורה השניה המשתמשת באופרטור '+=' והשורה השלישית מבצעות בדיוק אותה פעולה:

int a = 5;
a += 3;
a = a + 3;

קיימים אופרטורים נוספים: '=%' , '=/' , '=*' , '=-'. 
האופרטור '=-' מבצע חיסור והצבה באותה פעולה, וכנ"ל לגבי שאר האופרטורים מסוג זה.

אופרטור חיבור מחרוזות

האופרטור היחיד שעובד על מחרוזות הוא אופרטור '+'. אופרטור זה משרשר שתי מחרוזות.

לדוגמא, הקוד הבא משרשר את המחרוזת "Hello " למחרוזת "World" לקבלת מחרוזת אחת "Hello World":

string a = "Hello ";
string b = "World";
string c = a + b; // "Hello World"

בחלק הקודם למדנו על אופרטורים אריתמטיים. בחלק זה נלמד על אופרטורים שמחזירים תוצאות מטיפוס bool, כלומר מחזירים true או false. 

אופרטורים שעובדים על משתני אמת/שקר

כזכור, משתנים מטיפוס bool יכולים להכיל רק אחד משני הערכים true או false. 
האופרטורים הבאים יכולים לפעול רק על משתנים מטיפוס bool.

האופרטור '!' עובד על משתנה יחיד מטיפוס bool ומחזיר את ההפך מערך המשתנה, כלומר אם המשתנה מכיל את הערך true האופרטור יחזיר false, ולהיפך. 
לדוגמא, הקוד הבא מציב false במשתנה מסוג bool ואז משתמש באופרטור '!' בשביל להפוך את הערך:

bool myValue = false;
myValue = !myValue; // myValue = true

האופרטור && עובד על שני משתנים מטיפוס bool ומחזיר true רק אם שני המשתנים מכילים true. 
לדוגמא, בקוד הבא בשורה הראשונה נקבל את הערך true ואילו בשורה השנייה והשלישית נקבל false:

bool myValue1 = true && true;
bool myValue2 = true && false;
bool myValue3 = false && true;

ניתן לסכם את הפעולה בטבלה הבאה (טבלת אמת):

האופרטור '||' עובד על שני משתנים מטיפוס bool ומחזיר true אם לפחות אחד מהמשתנים מכיל true. 
ניתן לסכם את פעולת האופרטור '||' בטבלת האמת הבאה:

אופרטורים להשוואה

האופרטורים הבאים משמשים להשוואה בין זוגות של מספרים:

האופרטור '>' מחזיר true אם ורק אם המשתנה בצד שמאל קטן ממש מהמשתנה בצד ימין. 
לדוגמא, הקוד הבא מציב במשתנה result1 ערך true ואילו במשתנה result2 ערך false: 

 bool result1 = 3 < 5; // true

 bool result2 = 4 < 4; // false

האופרטור '<' מחזיר true אם ורק אם המשתנה בצד שמאל גדול ממש מהמשתנה בצד ימין.

לדוגמא, הקוד הבא מציב במשתנה result1 ערך true ואילו במשתנה result2 ערך false:

bool result1 = 5 > 3; // true
bool result2 = 4 > 4; // false

האופרטור '=>' מחזיר true אם ורק אם המשתנה בצד שמאל קטן או שווה מהמשתנה בצד ימין. 
האופרטור '=<' מחזיר true אם ורק אם המשתנה בצד שמאל גדול או שווה מהמשתנה בצד ימין.

האופרטור '==' מחזיר true אם ורק אם המשתנים בשני הצדדים שווים. 
האופרטור '=!' מחזיר true אם ורק אם המשתנים בשני הצדדים שונים. 
לדוגמא, הקוד הבא מציב במשתנה result1 ערך true ואילו במשתנה result2 ערך false:

bool result1 = 5 == 5; // true
bool result2 = 4 != 4; // false

בחלק הקודם למדנו על אופרטורים בוליאניים. בחלק זה נלמד על אופרטורים שעובדים על מספרים ברמה של הסיביות.

אופרטורים בינאריים שעובדים על מספרים

אופרטורים אלו מסתכלים על מספר שלם בייצוג הבינארי שלו (אפסים ואחדות) ומבצעים את הפעולה על כל ביט בנפרד.

האופרטור '&' מופעל על שני מספרים ומבצע את פעולתו על ביט בנפרד (נקרא bitwise AND). 
נראה דוגמא מפורטת לכך, נראה לחשב מה התוצאה של 5 & 7:

ראשית נסתכל על הייצוג הבינארי של המספר 5: 00000101 
כעת נסתכל על הייצוג הבינארי של המספר 6: 00000110

הערה: ניתן לקרוא כיצד ניתן למצוא את הייצוג הבינארי של כל מספר בלינק הזה.

כעת נבצע את אופרטור '&' על כל סיבית בנפרד ונקבל את המספר 4: 00000100

//   00000101 = 5
// & 00000110 = 6
//   ========
//   00000100 = 4
byte x = 5 & 6; // x = 4

להלן טבלת האמת שמתאימה לאופרטור '&' עבור כל זוג ביטים:

באופן דומה פועל האופרטור '|' (נקרא bitwise OR) על כל זוג סיביות. 
להלן טבלת האמת שמתאימה לאופרטור '|':

להלן טבלת האמת עבור אופרטור '^' (נקרא גם bitwise XOR):

האופרטור '~' עובד על מספר שלם בודד והופך כל סיבית במספר. 
להלן טבלת האמת עבור האופרטור '~':

אופרטורי הזזה

אופרטורי ההזזה עובדים על מספר שלם ומבצעים הזזה של היצוג הבינארי שלו ימינה או שמאלה.

האופרטור '>>' מבצע הזזה שמאלה של המשתנה המופיע מימין לאופרטור, המשתנה המופיע משמאל לאופרטור מייצג את מספר הצעדים שיש לעשות.

לדוגמא, ההצגה הבינארית של המספר 5 היא 00000101. אם נזיז את ההצגה הזו פעמיים שמאלה נקבל 00010100 שהוא הייצוג הבינארי של המספר 20. 
פעולה זו מתבצעת בקוד ע"י:

int a = 5;         // 00000101 = 5
int b = a << 2;    // 00010100 = 20

באופו דומה, האופרטור '<<' מבצע הזזה ימינה של המשתנה המופיע מימין לאופרטור, המשתנה המופיע משמאל לאופרטור מייצג את מספר הצעדים שיש לעשות. 
לדוגמא, הקוד הבא מבצע הזזה ימינה של המספר 20 וע"י כך נקבל את המספר 5:

int a = 20;        // 00010100 = 20
int b = a >> 2;    // 00000101 = 5

אופרטורי הצבה בינאריים

באופן דומה לאופרטורי הצבה אריתמטיים, קיימים אופרטור הצבה בינאריים שמשמשים לכתיבה מקוצרת של האופרטורים הבינאריים הרגילים. 
האופרטור '=&' מבצע '&' ומציב את התוצאה באותה פעולה.

לדוגמא, בקוד הבא השורה השניה המשתמשת באופרטור '=&' והשורה השלישית מבצעות בדיוק אותה פעולה:

int a = 5;
a &= 6;
a = a & 6;

קיימים אופרטורים נוספים: '=<<' , '=>>' , '=^' , '=|'. 
האופרטור '=|' מבצע '|' והצבה באותה פעולה, וכנ"ל לגבי שאר האופרטורים מסוג זה.

בחלק זה נלמד כיצד להשתמש בתנאי if. 

משפט if בסיסי

לפעמים עולה צורך לבצע קטע קוד מסויים רק כאשר מתקיים איזשהו תנאי. 
לדוגמא נרצה להדפיס למשתמש את המחרוזת "Hello" רק אם משתנה age מכיל ערך גדול או שווה ל18. 
לצורך זה נוכל להשתמש במשפט if באופן הבא:

if (age >= 18)
{
    Console.WriteLine("Hello");
}

באופן כללי משפט if יראה בצורה הבאה:

if (condition)
{
    פקודות כלשהן
}

כאשר condition מציין איזשהו ביטוי מטיפוס bool ואילו statements מציין אוסף פקודות שנרצה להריץ במקרה שהביטוי condition הוא true.

בתור condition ניתן לשים כל ביטוי שהתוצאה שלו היא bool, בדרך כלל נשתמש באופרטורים הבוליאניים שלמדנו עליהם בחלק קודם של המדריך.

להלן מספר דוגמאות בעלי תנאים מסוגים שונים:

• קטע הקוד שבתנאי תמיד מתבצע:

if (true)
{
    Console.WriteLine("runs always");
}

• קטע הקוד שבתנאי אף פעם לא מתבצע:

if (false)
{
    Console.WriteLine("never runs");
}

• קטע הקוד שבתנאי מתבצע אם המשתמש הכניס את הערך "arik":

string name = Console.ReadLine();
if (name == "arik")
{
    Console.WriteLine("runs if name is arik");
}

קטע הקוד שבתנאי מתבצע אם המשתמש הכניס את הערך "arik" וגם משתנה age מכיל ערך שגדול מ 18:

if ((name == "arik") && (age > 18))
{
    Console.WriteLine("name is arik AND age is bigger than 18");
}

משפט if-else

באמצעות משפט if-else ניתן לבצע קוד מסוים כאשר התנאי ב if הוא true ולבצע קוד אחר כאשר התנאי הואfalse. 
המבנה הכללי של משפט if-else יראה בצורה הבאה:

if (condition)
{
    // statements to run if condition is true
}
else
{
    // statements to run if condition is false
}

להלן מספר דוגמאות המשתמשות במשפט if-else:

• בדוגמא זו תודפס למסך הודעה בהתאם לשם המשתמש שהוכנס:

string name = Console.ReadLine();
if (name == "arik")
{
    Console.WriteLine("runs if name is arik");
}
else
{
    Console.WriteLine("runs if name is not arik");
}

• בדוגמא זו תודפס למסך הודעה אם מתקיימים שני התנאים, לעומת זאת אם לפחות אחד התנאים אינו מתקיים תודפס הודעה אחרת:

string name = Console.ReadLine();
if ((name == "arik") && (age > 18))
{
    Console.WriteLine("name is arik AND age is > 18");
}
 
else
{
    Console.WriteLine("name is not arik OR age is not > 18");
}

בחלק קודם למדנו כיצד להשתמש במשפט if-else. בחלק זה נרחיב את הידע ונלמד כיצד לכתוב משפטי if מקוננים. 

משפטי if מקוננים

פירוש הביטוי משפטי if מקוננים הוא: משפט if שנמצא בתוך משפט if אחר. 
לדוגמא נרצה לכתוב תוכנית שקולטת מהמשתמש שם ויום בשבוע ומדפיסה הודעה לפי הלוגיקה הבאה: 

• אם שם המשתמש הוא "arik" והיום בשבוע הוא "friday" או "saturday" תודפס ההודעה "go back to sleep"
• אם שם המשתמש הוא "arik" והיום בשבוע אינו "friday" או "saturday" תודפס ההודעה "go to work"
• אם שם המשתמש אינו "arik" תודפס ההודעה "unknown user"

להלן הפתרון, שימו לב לשימוש במשפט if בתוך משפט ה if הראשון:

// get user name 
Console.Write("Enter user name: ");
string name = Console.ReadLine();
 
// get day
Console.Write("Enter day: ");
string day = Console.ReadLine();
 
// print message according to user name and day
if (name == "arik")
{
    if ((day == "friday") || (day == "saturday"))
    {
        Console.WriteLine("go back to sleep");
    }
    else
    {
        Console.WriteLine("go to work");
    }
}
else
{
    Console.WriteLine("unknown user");
}

משפט if מרובה

לפעמים נרצה לבצע בדיקה רבה של תנאים ובכל תנאי לבצע פקודות שונות. לצורך כך נכתוב מספר תנאי if מקוננים.

לדוגמא, נרצה לכתוב תוכנית שמקבלת ציון מספרי בין 0 ל 100 מהמשתמש ומדפיסה ציון באותיות לפי הכללים הבאים: 

• אם הציון בין 90 ל 100 יודפס הציון "A"
• אם הציון בין 80 ל 89 יודפס הציון "B"
• אם הציון בין 70 ל 79 יודפס הציון "C"
• אם הציון בין 60 ל 69 יודפס הציון "D"
• בכל מקרה אחרי יודפס הציון "F"

להלן פתרון אפשרי:

string gradeString = Console.ReadLine();
int grade = Convert.ToInt32(gradeString);
if ((grade >= 90) && (grade <= 100))
{
    Console.WriteLine("A");
}
else
{
    if ((grade >= 80) && (grade <= 89))
    {
        Console.WriteLine("B");
    }
    else
    {
        if ((grade >= 70) && (grade <= 79))
        {
            Console.WriteLine("C");
        }
        else
        {
            if ((grade >= 60) && (grade <= 69))
            {
                Console.WriteLine("D");
            }
            else
            {
                Console.WriteLine("F");
            }
        }
    }
}

הערה: הפקודה Convert.ToInt משמשת להמרה של המחרוזת gradeString למשתנה מספרי grade.

לחילופין נוכל לבחור לכתוב זאת קצת אחרת ונקבל תוכנית שהרבה יותר נוחה לקריאה:

string gradeString = Console.ReadLine();
int grade = Convert.ToInt32(gradeString);
if ((grade >= 90) && (grade <= 100))
{
    Console.WriteLine("A");
}
else if ((grade >= 80) && (grade <= 89))
{
    Console.WriteLine("B");
}
else if ((grade >= 70) && (grade <= 79))
{
    Console.WriteLine("C");
}
else if ((grade >= 60) && (grade <= 69))
{
    Console.WriteLine("D");
}
else
{
    Console.WriteLine("F");
}

בחלקים הקודמים במדריך למדנו כיצד לעבוד עם משתנים וכיצד להשתמש במשפטי if. בחלק זה נלמד על לולאתfor. 

מה זה לולאה?

לולאה היא קטע קוד שנרצה שיתבצע מספר פעמים. 
לדוגמא תארו לכם שנרצה להדפיס למסך 3 פעמים את המשפט "Welcome", אופציה אחת היא לכתוב תוכנית שמשתמשת בפונקציה Console.WriteLine 3 פעמים:

Console.WriteLine("Welcome");
Console.WriteLine("Welcome");
Console.WriteLine("Welcome");

אופציה זו היא יחסית סבירה, אבל מה יקרה אם נרצה להדפיס זאת 30 פעמים? או 300? 
בשביל זה נשתמש בלולאה שבה יהיה כתוב מה רוצים לבצע ומספר הפעמים הדרוש. 

לולאת for

for (int i = 0; i < 3; ++i)
{
    Console.WriteLine("Welcome");
}

נסביר כעת את דוגמא זו:

קטע הקוד: int i = 0 מתבצע פעם אחת בלבד בתחילת הלולאה, פה אנו מאתחלים משתנה חדש מטיפוס int בשם i שיספור כמה פעמים גוף הלולאה כבר התבצע, בהתחלה משתנה זה מכיל את הערך 0.

קטע הקוד i < 3 מתבצע לפני כל ריצה של גוף הלולאה, אם הערך הוא true גוף הלולאה מתבצע, אחרת התוכנית מפסיקה את הלולאה ועוברת לקטע קוד שמופיע אחריה.

קטע הקוד ++i מתבצע אחרי כל ריצה של גוף הלולאה, תפקידו לקדם את הערך במשתנה i כדי לספור כמה פעמים התבצע גוף הלולאה.

לבסוף, קטע הקוד Console.WriteLine משמש בתור גוף הלולאה, זהו הקוד שנרצה שירוץ בכל פעם.

באופן כללי, לולאת for נראית בצורה הבאה:

for (before-statement; condition; after-statement)
{
    //loop-body
}

דוגמאות נוספות לשימוש בלולאת for 

• קליטת שם משתמש והדפסתו 10 פעמים

Console.Write("Enter name: ");
string name = Console.ReadLine();
for (int i = 0; i < 10; ++i)
{
    Console.WriteLine("Your name is " + name);
}

• הדפסת כל המספרים הזוגיים בין 1 ל 10:

for (int i = 0; i <= 10; i += 2)
{
    Console.WriteLine(i);
}

• הדפסת הסכום 1+2+3 וכו' עד 10:

int sum = 0;
for (int i = 1; i <= 10; ++i)
{
    sum += i;
}
Console.WriteLine("Sum is: " + sum);

בחלק הקודם למדנו על שימוש בלולאת for. בחלק זה נלמד כיצד להשתמש בלולאת while. 

לולאת while

לולאת while הינה עוד סוג של לולאה בשפת #C, כלומר היא נשתמש בה כאשר נרצה לבצע קטע קוד מספר לא ידוע מראש כלשהוא של פעמים.

ללולאת while יש את המבנה הבא:

while (condition)
{ 
    statements
}

במבנה הזה הביטוי condition הוא תנאי שהלולאה בודקת לפני ביצוע גוף הלולאה. גוף הלולאה מתבצע רק אם הביטוי condition מחזיר ערך true.

הביטוי statements הוא גוף הלולאה.

לדוגמא, התוכנית הבאה מבצעת הדפסה של המחרוזת "Using while loop" 3 פעמים:

int i = 0;
while (i < 3)
{
    Console.WriteLine("Using while loop");
}

נעיר כי תוכנית זו יכלה גם להשתמש בלולאת for כפי שראינו בחלק הקודם.

להלן דוגמא נוספת, בה אנו קולטים שמות מהמשתמש ומדפיסים הודעת "Welcome" לכל אחד מהשמות, עד אשר המשתמש מכניס שם ריק "":

Console.WriteLine("Enter name: ");
string name = Console.ReadLine();
while (name != "")
{
    Console.WriteLine("Welcome " + name + "!");
    name = Console.ReadLine();
}

שימו לב שבדוגמא זו לא ידוע מראש כמה פעמים גוף הלולאה יתבצע, מאחר וזה תלוי בקלט של המשתמש. 

while או for?

באופן כללי, כל לולאת for ניתן לכתוב גם כלולאת while ולהיפך, שכן קטעי הקוד הבאים שקולים:

לולאת for כללית:

for (before-statement; condition; after-statement)
{
    loop-body
}

לולאת while שקולה:

before-statement
while (condition)
{
    loop-body
}
after-statement

בדרך כלל נבחר להשתמש בלולאת for כאשר ידוע מספר הפעמים שגוף הלולאה יתבצע ואילו נשתמש בלולאתwhile כאשר מספר הפעמים לא ידוע מראש ותלוי באיזשהו תנאי מורכב יותר.

בחלק הקודם למדנו על שימוש בלולאת while. בחלק זה נלמד כיצד להשתמש בלולאת do.

לולאת do

לולאת do מבצעת קודם את גוף הלולאה ולאחריה בודקת האם צריך להמשיך בלולאה לחזרות נוספות.

המבנה הכללי של לולאת do הוא:

do
{
    statement
}
while (condition);

נשים לב שגוף הלולאה (statement) מתבצע תמיד לפחות פעם אחת, זאת מאחר והתנאי (condition) נבדק רק בסוף הלולאה. 

דוגמאות לשימוש בלולאת do 

• בדוגמא זו אנו קולטים שמות מהמשתמש כל עוד המשתמש לא הכניס שם ריק:

string name;
do
{
    Console.WriteLine("Enter name: ");
    name = Console.ReadLine();
}
while (name != "");

• בדוגמא זו אנו מחשבים את מכפלת המספרים 1*2*3*…*10:

int i = 0;
int result = 1;
do
{
    ++i;
    result *= i;
}
while (i < 10);
Console.WriteLine(result);

בחלק זה נלמד כיצד להשתמש במשפט switch.

משפט switch

משפט switch מאפשר לנו לבחון משתנה ולבצע קטעי קוד שונים לפי ערכים שונים שהוא יכול לקבל.

לדוגמא, בתוכנית הבאה נרצה לקבוע את מחיר הקפה לפי הגודל המבוקש:

Console.Write("Enter cup size (big / medium / small): ");
string cupSize = Console.ReadLine();
 
int price = 0;
switch (cupSize)
{
    case "big":
        price = 15;
        break;
 
    case "medium":
        price = 13;
        break;
 
    case "small":
        price = 9;
        break;
 
    default:
        Console.WriteLine("Invalid cup size!");
        break;
}
 
if (price != 0)
{
    Console.WriteLine("The coffee price is " + price);
}

הסבר התוכנית: ראשית אנו מבקשים מהמשתמש את גודל כוס הקפה המבוקש.

המשתנה cupSize מכיל את הגודל המבוקש, בהתאם לכך אנו מבצעים משפט switch שבוחן את הערך של cupSize ומבצע קוד המתאים לערך הקיים בו. 
אם הערך הוא "big" התוכנית מציבה למשתנה price את הערך 15 ויוצאת ממשפט ה switch. 
אם הערך הוא "medium" התוכנית מציבה למשתנה price את הערך 13 ויוצאת ממשפט ה switch. 
אם הערך הוא "small" התוכנית מציבה למשתנה price את הערך 9 ויוצאת ממשפט ה switch. 
בכל מקרה אחר, התוכנית מדפיסה הודעת שגיאה "Invalid cup size!".

לבסוף אנו מדפיסים את מחיר הקפה.

נשים לב לשימוש בפקודה break, חייבים לשים אותה בסוף כל מקרה (case) במשפט הswitch. 

if או switch?

נעיר כי כל משפט switch יכול להיות מוחלף בסדרה של משפטי if מקוננים (ראה חלק קודם במדריך), אך לא להיפך. 
מומלץ להשתמש במשפט switch אם ניתן, מאחר והקוד של התוכנית יוצא יותר ברור.

לדוגמא, אותה תוכנית אשר הייתה משתמשת במשפטי if מקוננים הייתה נראית כך:

Console.Write("Enter cup size (big / medium / small): ");
string cupSize = Console.ReadLine();
 
int price = 0;
 
if (cupSize == "big")
{
    price = 15;
}
else if (cupSize == "medium")
{
    price = 13;
}
else if (cupSize == "small")
{
    price = 9;
}
else
{
    Console.WriteLine("Invalid cup size!");
}
 
if (price != 0)
{
    Console.WriteLine("The coffee price is " + price);
}

איחוד מקרים

לפעמים נרצה לאחד כמה מקרים שונים כך שיבצעו את אותו קוד, במקרה כזה נוכל לשים כמה משפטי case רצופים (ללא שימוש בbreak ביניהם).

לדוגמא, בקטע הקוד הבא נבקש מהמשתמש להכניס מספר בין 1 ל 10 ונדפיס האם הוא זוגי הוא אי-זוגי:

Console.Write("Enter number (1-10): ");
string numberString = Console.ReadLine();
int number = Convert.ToInt32(numberString);
 
switch (number)
{
    case 1:
    case 3:
    case 5:
    case 7:
    case 9:
        Console.WriteLine("number is odd");
        break;
 
    case 2:
    case 4:
    case 6:
    case 8:
        Console.WriteLine("number is event");
        break;
 
    default:
        Console.WriteLine("number is not in range");
        break;
}

בחלק זה נלמד כיצד להשתמש במשפטים continue ו break בתוך לולאות.

משפט continue

במשפט continue ניתן להשתמש רק כאשר אנו נמצאים בתוך לולאה. 
משפט continue מאפשר לנו לדלג על שארית הקוד בגוף הלולאה.

לדוגמא, הקוד הבא מדפיס את רשימת המספרים האי-זוגיים בין 1 ל 10:

for (int i = 1; i <= 10; ++i)
{
    if (i % 2 == 0)
    {
        continue;
    }
 
    Console.WriteLine(i);
}

הסבר: בתוך גוף הלולאה אנו בודקים האם המספר הנוכחי הוא זוגי (i % 2 == 0) ואם כן, אנו מדלגים לאינטרציה הבאה של הלולאה. 
במקרה אחר (המספר הוא אי-זוגי) אנו מדפיסים את המספר למסך.

שימוש במשפט continue אפשרי גם בלולאות מסוגים אחרים.

משפט break

במשפט break נשתמש כאשר נרצה להפסיק את ריצת הלולאה.

לדוגמא, הקוד הבא מדפיס את המספרים 1 עד 5, למרות שנראה ממבט ראשון שהלולאה היא אינסופית:

int i = 0;
while (true)
{
    ++i;
 
    if (i > 5)
    {
        break;
    }
 
    Console.WriteLine(i);
}

בחלקים קודמים למדנו על הסוגים השונים של לולאות בשפת #C. בחלק זה נלמד מהן לולאות מקוננות ונראה מספר דוגמאות. 

מה זה לולאה מקוננת?

לולאה מקוננת הינה לולאה שמוגדרת בתוך לולאה אחרת. 
כאשר משתמשים בלולאה מקוננת צריך לזכור להשתמש במשתנה אחר מאשר המשתנה שכבר משתמשים בו בלולאה הראשונה.

לדוגמא, אם נרצה להדפיס את לוח הכפל, נזדקק לשתי לולאות, אחת שתעבור על השורות ואחת שתעבור על העמודות. 
קטע הקוד הבא מראה שימוש בלולאה מקוננת לצורך הדפסת לוח הכפל:

for (int i = 1; i <= 10; ++i)
{
    for (int j = 1; j <= 10; ++j)
    {
        Console.Write(i * j);
        Console.Write(" ");
    }
    Console.WriteLine();
}

בדוגמא זו הלולאה הראשונה (שמשתמשת במשתנה i) עוברת על השורות, ואילו הלולאה השניה מדפיסה את כל העמודות בשורה בודדת.

תוצאת הרצת התוכנית הזו היא:

מספרים ראשוניים

במתמטיקה, מספר נקרא ראשוני אם הוא מתחלק רק בעצמו ובאחד, לדוגמא 2,3,5 הם מספרים ראשוניים ואילו 4 אינו ראשוני, כי 2 מחלק אותו.

נרצה לבנות תוכנית שמציגה את כל המספרים הראשוניים בטווח 2 עד 100. 
בקטע הקוד הבא אנחנו מבצעים שתי לולאות. בלולאה הראשונה (החיצונית) אנו עוברים על כל המספרים מ 2 עד 100, ואילו בלולאה השניה (הפנימית) אנו בודקים כל מספר האם הוא מתחלק במספר שקטן ממנו. במידה ומצאנו מספר שאינו מתחלק באף מספר שקטן ממנו אנו מדפיסים אותו למסך.

bool isPrime = false;
int number = 2;
while (number <= 100)
{
    isPrime = true;
    for (int i = 2; i < number; ++i)
    {
        if (number % i == 0)
        {
            isPrime = false;
            break;
        }
    }
    if (isPrime)
    {
        Console.Write(number);
        Console.Write(" ");
    }
    number++;
}

תוצאת הרצת התוכנית הזו היא:

בחלק זה נלמד כיצד להגדיר ולהשתמש בפונקציות.

מה זה פונקציה?

פונקציה הוא קטע קוד בעל שם, כדי להריץ את קטע הקוד ניתן פשוט לכתוב את שמו.

השתמשנו כבר במספר פונקציות במהלך המדריך, לדוגמא הפונקציה Console.WriteLine היא פונקציה ששייכת למחלקה Console ושמה הוא WriteLine. 
הפונקציה WriteLine מקבלת בתור פרמטר את מה שאנו רוצים להדפיס למסך והיא מדפיסה אותו.

בנוסף נשים לב שבכל תוכנית שאנו כותבים יש לפחות פונקציה אחת, והיא הפונקציה Main. פונקציה זו היא נקודת הפתיחה של התוכנית שלנו:

static void Main(string[] args)
{
 
}

כיצד מגדירים פונקציה?

כעת נראה כיצד אנו יכולים להגדיר פונקציה משלנו. 
ראשית נציין שהגדרת פונקציה נמצאת מחוץ להגדרה של הפונקציה Main אבל בתוך המחלקה שבה אנו נמצאים. 
לדוגמא אם הקוד שנוצר כאשר אנו פותחים פרויקט חדש הוא:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
 
        }
    }
}

אזי נכתוב את הקוד של הפונקציה שלנו ליד הפונקציה Main, כלומר אחריה או לפניה, אבל בשום אופן לא בתוכה.

לצורך דוגמא, נגדיר פונקציה בשם PrintNameTwoTimes שקולטת מהמשתמש את שמו ומדפיסה אותו פעמיים למסך. 
לצורך הבנה של מיקום הפונקציה ביחס לפונקציה Main נביא את הקוד במלואו:

using System;
using System.Collections.Generic;

using System.Text; 
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            PrintNameTwoTimes();
        }
 
        static void PrintNameTwoTimes()
        {
            Console.Write("Enter name: ");
            string name = Console.ReadLine();
            Console.WriteLine(name);
            Console.WriteLine(name);
        }
    }
}

בקטע קוד זה הגדרנו פונקציה בשם PrintNameTwoTimes, שמבצעת קוד מסויים וקראנו לפונקציה זו מתוך הפונקציה הראשית Main.

שימו לב שאם לא היינו קוראים לפונקציה, התוכנית לא הייתה מבצעת דבר! 
הריצה של התוכנית מתחילה תמיד מפונקציית הMain ומבצעת רק מה שכתוב שם. 

דוגמא נוספת לפונקציה

כעת נכתוב פונקציה שמחשבת את סכום המספרים 1 עד 100 ומדפיסה אותו למסך. 
נקרא לפונקציה זו פעמיים מתוך פונקציית ה Main:

class Program
{
    static void Main(string[] args)
    {
        PrintSum1To10();
        PrintSum1To10();
    }
 
    static void PrintSum1To10()
    {
        int sum = 0;
        for (int i = 1; i <= 10; ++i)
        {
            sum += i;
        }
        Console.WriteLine(sum);
    }
}