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

מה הם פרמטרים של פונקציה?

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

הגדרת פרמטרים לפונקציה

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

לדוגמא, הפונקציה הבאה מגדירה שתי פרמטרים מטיפוס string בעלי השמות firstName ו lastName, הפונקציה משתמשת בפרמטרים בשביל להדפיסם למסך:

static void PrintFullName(string firstName, string lastName)
{
    Console.WriteLine("Full name: " + firstName + " " + lastName);
}

העברת ערכים בקריאה לפונקציה

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

לדוגמא, כדי לקרוא לפונקציה שהגדרנו בסעיף הקודם נבצע:

static void Main(string[] args)
{
    PrintFullName("Arik", "Poznanski");
}

בדוגמא זו הערך "Arik" מועבר לפונקציה בתור הפרמטר firstName ואילו הערך "Poznanski" מועבר לפונקציה בתור הפרמטר lastName.

החזרת ערך מפונקציה

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

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

static int Add(int x, int y)

ה- int שמופיע לפני שם הפונקציה Add מציין את טיפוס ערך ההחזרה של הפונקציה.

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

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

static int Add(int x, int y)
{
    return x + y;
}

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

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

static void Main(string[] args)
{
    int z = Add(5, 3);
}

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

הקדמה

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

static void swap(int x, int y)
{
    int z = x;
    x = y;
    y = z;
}

פונקציה זו מקבלת שני פרמטרים מטיפוס int בשם x ו y ומבצעת החלפה בערכים שלהם בעזרת משתנה עזר z. 
כעת נכתוב תוכנית שקוראת לפונקציה swap על שני משתנים בשם a ו b ומדפיסה את הערכים שלהם לפני ואחרי הקריאה:

static void Main(string[] args)
{
    int a = 5;
    int b = 7;
    
    Console.WriteLine("a = " + a.ToString());
    Console.WriteLine("b = " + b.ToString());
    swap(a, b);
    Console.WriteLine("a = " + a.ToString());
    Console.WriteLine("b = " + b.ToString());
}

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

כלומר, למרות שהפעלנו את הפונקציה swap המשתנים לא הוחלפו!

אז מה קורה כאן?

הסיבה שלא ראינו שינוי בערכים של a ו b היא שכאשר מעבירים לפונקציה ערכים בשפת C#, הערכים מועתקיםלתוך הפרמטרים. 
אם נזכור שמאחורי כל משתנה יש איזשהו תא בזיכרון שמכיל את הערך שלו, אז במקרה שלנו יצרנו 2 תאים נוספיםשמכילים העתקים של התאים המקוריים.

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

פרמטר מסוג ref

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

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

בדוגמא שלנו ההגדרה צריכה להיות:

static void swap(ref int x, ref int y)
{
    int z = x;
    x = y;
    y = z;
}

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

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

static void Main(string[] args)
{
    int a = 5;
    int b = 7;
    
    Console.WriteLine("a = " + a.ToString());
    Console.WriteLine("b = " + b.ToString());
    swap(ref a, ref b);
    Console.WriteLine("a = " + a.ToString());
    Console.WriteLine("b = " + b.ToString());
}

והרצת התוכנית תיתן את הפלט:

כעת אנו רואים שהערכים של המשתנים a ו b אכן התחלפו כנדרש. 

פרמטר מסוג out

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

לצורך כך נוכל להגדיר פרמטר של הפונקציה בתור פרמטר out, ע"י הוספת המילה out לפני הגדרת הטיפוס שלו.

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

static string GetMultipleValues(out string firstName, out string lastName)
{
    Console.Write("Enter first name: ");
    firstName = Console.ReadLine();
 
    Console.Write("enter last name: ");
    lastName = Console.ReadLine();
 
    return firstName + " " + lastName;
}

פונקציה זו קולטת מהמשתמש ערכים לתוך הפרמטרים firstName ו lastName ובנוסף מחזירה ערך שמכיל את השם המלא.

בעת הקריאה לפונקציה עם פרמטר מטיפוס out יש לציין את המילה out לפני שם המשתנה:

static void Main(string[] args)
{
    string full, first, last;
    full = GetMultipleValues(out first, out last);
}

בפונקציה זו אנו מגדירים ראשית 3 משתנים מטיפוס string. 
לאחר מכן אנו קוראים לפונקציה GetMultipleValues ומעבירים לה את הפרמטרים first ו last תוך הוספת המילהout לפני. 
המשתנה full יקבל את ערך ההחזרה הרגיל של הפונקציה ואילו המשתנים first ו last יקבלו את הערכים שיקלטו מהמשתמש.

בחלק זה נלמד על כיצד לעבוד עם מערכים בשפת #C. 

מה זה מערך?

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

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

בדוגמא בציור יש לנו מערך של משתנים מטיפוס int בשם arr, המערך הוא בגודל 10. 
הפניה למערך מתבצעת באמצעות שם המערך והאינדקס לאיבר, שימו לב שהאינדקס בשפת #C מתחיל מ 0, כלומר [arr[0 הוא האיבר הראשון במערך, [arr[1 הוא האיבר השני וכו' 

כיצד יוצרים מערך?

כדי לראות כיצד ליצור מערך, נתבונן בדוגמא הבא:

int[] arr = new int[10];

בדוגמא זו יצרנו מערך של int בשם arr, בעל גודל 10. 
ראשית הגדרנו את סוג המשתנה []int, כלומר מערך של int, לאחר מכן נתנו לו שם arr ואז ביקשו להקצות זיכרון ל10 תאים ע"י שימוש בפקודה new.

נראה דוגמא נוספת:

string[] myStrings = new string[500];

בדוגמא זו יצרנו מערך של string בשם myStrings בעל גודל 500, כלומר נוכל לאכסן במערך שלנו 500 משתנים מטיפוס string.

כיצד משתמשים במערך?

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

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

arr[0] = 5;

הקוד הבא ניגש לתא השלישי במערך myStrings ומציב שם את הערך "Hello":

myStrings[2] = "Hello";

כיצד עוברים על איברי המערך?

כדי לעבור על איברי המערך נשתמש בדרך כלל בלולאה. 
לדוגמא, לולאת for הבאה עוברת על איברי המערך arr ומציבה בהם את הספרים 1 עד 10:

for (int i = 0; i < arr.Length; ++i)
{
    arr[i] = i + 1;
}

שימו לב לשימוש בתכונה Length של המערך arr, תכונה זו מחזירה את גודל המערך, במקרה שלנו arr.Length מחזירה את הערך 10.

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

static void Main(string[] args) 
{ 
    int[] arr = new int[10]; 
    string tempNumber; 
    for (int i = 0; i < arr.Length; ++i) 
    { 
        Console.Write("Enter number: "); 
        tempNumber = Console.ReadLine(); 
        arr[i] = Convert.ToInt32(tempNumber); 
    } 
}

דוגמא מסכמת

נראה כעת דוגמא לפונקציה שמקבלת מערך של int ומחזירה את הממוצע שלהם (מסוג double):

static double Average(int[] array)
{
    double sum = 0;
    for (int i = 0; i < array.Length; ++i)
    {
        sum += array[i];
    }
 
    return sum / array.Length;
}

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

מה זה מערך רב מימדי?

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

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

במערך זה יש שני מימדים, הראשון בגודל 3 והשני בגודל 10, ולכן סה"כ האיברים במערך הוא 30. 
בשביל לגשת לאיבר כלשהוא במערך צריך לתת את האינדקסים שלו בשני המימדים, לדוגמא arr[0,0] הוא האיבר בשורה הראשונה, בעמודה הראשונה.

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

יצירת מערך דו-מימדי

יצירת מערך דו-מימדי נעשית באופן דומה ליצירת מערך רגיל:

int[,] arr = new int[3, 10];

בדוגמא זו יצרנו מערך דו-מימדי בעל מימד ראשון בגודל 3 ומימד שני בגודל 10, סה"כ מספר האיברים במערך הוא 30. 

גישה לאיברי המערך הדו-מימדי

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

arr[2, 9] = 7;

מעבר על איברי מערך דו-מימדי

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

int[,] arr = new int[3, 10];
 
for (int i = 0; i < arr.GetLength(0); ++i)
{
    for (int j = 0; j < arr.GetLength(1); ++j)
    {
        arr[i, j] = (i + 1) * (j + 1);
    }
}

בדוגמא זו אנו עושים שימוש בפונקציה arr.GetLength, פונקציה זו מקבלת את מספר המימד ומחזירה את גודלו. 
כלומר קריאה לפונקציה (arr.GetLength(0 תחזיר את גודל המימד הראשון, 3, ואילו קריאה לפונקציה(arr.GetLength(1תחזיר את גודל המימד השני, 10.

נציין ששימוש בתכונה arr.Length תחזיר את סך כל האיברים במערך, כלומר 30.

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

לולאת foreach

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

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

// create array
string[] myStrings = new string[5];
 
// for loop
for (int i = 0; i < myStrings.Length; ++i)
{
    Console.Write("Enter string: ");
    myStrings[i] = Console.ReadLine();
}
 
// foreach loop
foreach (string currentString in myStrings)
{
    Console.WriteLine(currentString);
}

נשים לב למבנה הפשוט של לולאת foreach, אין משתנה מניה ואין גישה למערך בתוך גוף הלולאה. 
במקום זאת, המשתנה currentString מקבל ערך אחר בכל איטרציה של גוף הלולאה.

שימוש בלולאת foreach מאפשר לכתוב קוד שהוא יותר קריא ומסודר.

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

התכונה Length

לכל משתנה מטיפוס string יש תכונה בשם Length שמחזירה את אורך המחרוזת.

לדוגמא, קטע הקוד הבא מגדיר מחרוזת עם המילה "Hello World" ומדפיס את אורך המחרוזת, 11:

string myString = "Hello World";
Console.WriteLine(myString.Length);

גישה לאות בתוך המחרוזת

ניתן להתייחס למחרוזת כאילו היא הייתה מערך של תווים (char), כלומר נוכל לבקש מהמחרוזת להחזיר לנו אות שנמצאת בתא מסוים.

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

string myString = "Hello World";
char firstChar = myString[0];
char lastChar = myString[myString.Length - 1];
Console.WriteLine(firstChar); // prints H
Console.WriteLine(lastChar);  // prints d

שימו לב שכדי לגשת לתא האחרון במחרוזת משתמשים ב Length – 1, שכן מספור התאים מתחיל ב 0. 

הפונקציות ToLower ו ToUpper

זוג הפונקציות ToLower ו ToUpper מאפשרות לנו לבצע פעולה נפוצה במחרוזת שהיא שינוי מאותיות קטנות לאותיות גדולות.

לדוגמא, אם נפעיל את הפונקציה ToLower על המחרוזת "Hello World" נקבל "hello world", 
בנוסף, אם נפעיל את הפונקציה ToUpper על המחרוזת "Hello World" נקבל "HELLO WORLD". 
קטע הקוד הבא מדגים זאת:

string myString = "Hello World";
Console.WriteLine(myString.ToLower());
Console.WriteLine(myString.ToUpper());

להלן תוצאת הריצה של תוכנית זו:

הפונקציות TrimStart, TrimEnd, Trim

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

לדוגמא, נריץ את קטע הקוד הבא על המחרוזת " Hello World ":

Console.BackgroundColor = ConsoleColor.Blue;
string myString = "   Hello World   ";
Console.WriteLine(myString.TrimStart());
Console.WriteLine(myString.TrimEnd());
Console.WriteLine(myString.Trim());

ונקבל את התוצאה:

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

הפונקציות StartWith, EndWith

הפונקציה StartWith מאפשר לבדוק האם המחרוזת שלנו מתחילה במחרוזת אחרת. 
לדוגמא, הרצת הפונקציה StartWith על המחרוזת "Hello World" עם הפרמטר "Hello" תחזיר true מאחר והמחרוזת "Hello World" מתחילה במילה "Hello".

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

להלן דוגמה של איך ניתן לעבוד עם שתי הפונקציות הללו:

string myString = Console.ReadLine();
if (myString.StartsWith("Hello"))
{
    Console.WriteLine("Hello is at the start of the input");
}
 
if (myString.EndsWith("Hello"))
{
    Console.WriteLine("Hello is at the end of the input");
}

הפונקציה Replace

הפונקציה Replace מאפשרת לנו לבצע החלפה של כל המופעים של מחרוזת א' במחרוזת ב' בתוך המחרוזת שלנו.

לדוגמא, נניח שיש לנו מחרוזת את המחרוזת "Good morning, what a beautiful morning!", ונרצה להחליף את המילה "morning" במילה "night". 
נכתוב תוכנית שעושה זאת:

string before = "Good morning, what a beautiful morning!";
string after = before.Replace("morning", "night");
 
Console.WriteLine(before);
Console.WriteLine(after);

והתוצאה:

פונקציות נוספות

הפונקציה IndexOf מחפשת מחרוזת א' בתוך מחרוזת ב' ומחזירה את המיקום שלה. 
הפונקציה Substring מאפשרת להעתיק חלק ממחרוזת לתוך מחרוזת אחרת. 
הפונקציה CompareTo מאפשרת להשוות בין שתי מחרוזות לפי סדר ההופעה שלהם במילון.

למחלקה string פונקציות עזר נוספות ומומלץ לבחון אותן בעצמכם.

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

הטיפוס DateTime

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

יצירה של משתנה מטיפוס DateTime

יצירת משתנה DateTime מתבצעת באמצעות המילה new שכבר ראינו לה שימוש בחלקים הקודמים למדריך. 
בעת היצירה ניתן (אך לא חובה) להעביר פרמטרים על התאריך ההתחלתי שיהיה בתוך המשתנה.

לדוגמא, קטע הקוד הבא יוצר משתנה מטיפוס DateTime המכיל את התאריך 12/12/2005 והשעה 09:00, ומדפיס אותו למסך:

DateTime date = new DateTime(2005, 12, 12, 9, 0, 0);
Console.WriteLine(date);

התוצאה:

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

DateTime date = new DateTime(2005, 12, 12);
Console.WriteLine(date);

תכונות של DateTime

למשתנה מטיפוס DateTime יש תכונות נוחות המאפשרות לקבל את החלקים השונים מתוך התאריך או השעה.

לדוגמא, התכונה Year מחזירה את השנה של התאריך. 
באופן דומה קיימות תכונות Month , Day , Hour , Minute , Second ואפילו Millisecond שמחזירים את החודש, יום, שעה, שניה ואלפית השניה בהתאמה:

DateTime date = new DateTime(2005, 12, 12, 9, 0, 0);
Console.WriteLine(date);
Console.WriteLine("Year = " + date.Year.ToString());
Console.WriteLine("Month = " + date.Month.ToString());
Console.WriteLine("Day = " + date.Day.ToString());
Console.WriteLine("Hour = " + date.Hour.ToString());
Console.WriteLine("Minute = " + date.Minute.ToString());
Console.WriteLine("Second = " + date.Second.ToString());

מה השעה?

תכונה אחת מאוד שימושית במחלקה DateTime היא נקראת Now והיא מחזירה את התאריך והשעה הנוכחית.

לדוגמא, קטע הקוד הבא מציג את השעה:

DateTime currentTime = DateTime.Now;
Console.WriteLine(currentTime);

חיבור תאריכים

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

DateTime currentTime = DateTime.Now;
DateTime future = currentTime.AddDays(40);
Console.WriteLine(currentTime);
Console.WriteLine(future);

והתוצאה:

שימו לב שהוספת 40 יום לתאריך נעשתה תוך התחשבות במספר הימים בחודש הנוכחי.

באופן דומה לפונקציה AddDays קיימות הפונקציות AddYears , AddMonths , AddHours , AddMinutes ,AddSeconds שמוסיפות שנים, חודשים, שעות, דקות ושניות בהתאמה.

הדפסת תאריכים בפורמטים שונים

הפונקציה ToString היא פונקציה שקיימת לכל משתנה בשפת C#, והיא מאפשרת להמיר כל אוביקט למחרוזת.

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

DateTime currentTime = DateTime.Now;
Console.WriteLine(currentTime.ToString());
Console.WriteLine(currentTime.ToString("dd/MM/yyyy"));
Console.WriteLine(currentTime.ToString("yyyy-MM-dd HH:mm"));

הרצת התוכנית תיתן לנו:

בחלק זה נלמד כיצד ליצור טיפוסים חדשים מסוג enum. 

מהו טיפוס מסוג enum?

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

כיצד עובדים עם enum?

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

לדוגמא, הקוד הבא מגדיר enum בשם Month המכיל את ערכי החודשים השונים:

enum Month
{
    January, 
    February, 
    March, 
    April, 
    May, 
    June, 
    July, 
    August, 
    September, 
    October, 
    November, 
    December
}

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

כעת נוכל להשתמש בטיפוס החדש בתוכנית הראשית:

static void Main(string[] args)
{
    Month myMonth = Month.December;
    Console.WriteLine(myMonth);
}

מתי נשתמש בenum?

השימוש בטיפוס מסוג enum עוזר לקריאות של התוכנית ומונע שגיאות.

לדוגמא, התבוננו בקטע הקוד הבא:

if ((documentState == 1) && (userSelection == 2))
{
    SaveDocument();
}
else if ((documentState == 1) && (userSelection == 1))
{
    DiscardDocument();
}

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

if ((documentState == DocumentState.NotSaved) && 
    (userSelection == DocumentOperation.Save))
{
    SaveDocument();
}
else if ((documentState == DocumentState.NotSaved) && 
         (userSelection == DocumentOperation.Discard))
{
    DiscardDocument();
}

כאשר במקרה זה נגדיר שני טיפוסים מסוג enum באופן הבא:

enum DocumentOperation
{ 
    Load,
    Save,
    Discard
}
 
enum DocumentState
{ 
    Saved,
    NotSaved
}

בחלק זה נלמד כיצד ליצור טיפוסים חדשים מסוג struct. 

מהו טיפוס מסוג struct?

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

כיצד מגדירים טיפוס מסוג struct?

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

קטע הקוד הבא מגדיר טיפוס מסוג struct כדי לייצג אובייקט נקודה:

struct Point
{
    public double X;
    public double Y;
}

נעיר כי הגדרת ה- struct צריכה להיות מחוץ להגדרת המחלקה, שכן אנו מגידירים טיפוס חדש, בדומה להגדרתenum. 

כיצד משתמשים בstruct שהגדרנו?

השימוש ב- struct נעשה באופן דומה למשתנה רגיל. 
ראשית יש להקצות לו זיכרון בעזרת שימוש בפקודה new. 
לאחר מכן נוכל לפנות למשתנים של ה- struct שלנו (שנקראים גם שדות) ולכתוב ולקרוא את הערכים שלהם.

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

static void Main(string[] args)
{
    Point p1 = new Point();
    p1.X = 1;
    p1.Y = 2;
}

הגדרת struct מורכב

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

בהתאם לכך נגדיר טיפוס מסוג struct חדש בשם Rectangle שמכיל שני משתנים מסוג Point. 
בנוסף נראה כיצד אנו משתמשים באוביקט Rectangle החדש.

קוד התוכנית מובא כאן במלואו:

namespace StructDemo
{
    struct Point
    {
        public double X;
        public double Y;
    }
 
    struct Rectangle
    {
        public Point TopLeft;
        public Point BottomRight;
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Rectangle rect = new Rectangle();
            rect.TopLeft.X = 0;
            rect.TopLeft.Y = 0;
            rect.BottomRight.X = 100;
            rect.BottomRight.Y = 100;
        }
    }
}

 נהוג להתחיל שמות של מחלקות ושמות של פונקציות באות גדולה באנגלית (למשל, Person).

 נהוג להתחיל שמות של משתנים באות קטנה באנגלית (למשל, firstName).

  class Person
  {
    //כל מה שנכתוב כאן שייך למחלקה
  }

  class Person
  {
    public string firstName;
    public string lastName;
    public int id;
  }

Person p = new Person(); 

p.FirstName = "Lior";
p.LastName = "Zamir";
p.Id = 1234578889;

Console.WriteLine("Name: {0} {1}", p.FirstName, p.LastName);

class Person
{
  public string firstName;
  public string lastName;
  public int id;
 
  public void Print()
  {
    Console.WriteLine("Full Name: {0} {1}", firstName, lastName);
  }
}

p.Print();

Property הינו מנגנון המאפשר לממש את עקרון הכימוס (encapsulation). הרעיון הוא להסתיר את המשתנים ולחשוף אותם דרך מנגנון סינון ובקרה לצורכי בדיקת תקינות המידע. בכדי להסתיר את המשתנה יש להגדיר אותו כ- private ואת ה- Property שמאפשר את הגישה למשתנה יש להגדיר כ- public. ניתן לגשת למשתנה private אך ורק מתוך המחלקה.

  נהוג ששם המשתנה יתחיל באות קטנה ושם ה- property יהיה אותו השם, אך יתחיל באות גדולה.

  class Person
  {
    //Data members:
 
    private string firstName;
    private string lastName;
    private int id;
 
    //Properties:
 
    public string FirstName
    {
      get { return firstName; }
      set { firstName = value; }
    }
 
    public string LastName
    {
      get { return lastName; }
      set { lastName = value; }
    }
 
    public int Id
    {
      get { return id; }
      set { id = value; }
    }
 
    //Methods:
 
    public void Print()
    {
      Console.WriteLine("Name: {0} {1}", firstName, lastName);
    }
  }

      Person p = new Person();
 
      p.FirstName = "Lior";
      p.LastName = "Zamir";
      p.Id = 123456789;
 
      p.Print();

      p.FirstName = "Lior";

      string name = p.FirstName;

    public int Id
    {
      get { return id; }
      set
      {
        if (value > 999999999)
          return;
 
        id = value;
      }
    }

    public int Id
    {
      get { return id; }
    }

p.Id = 123456789;