מבוא ל-C#

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

יתר על כן, C# מציעה סט עשיר של תכונות וכלים, מה שהופך אותה לשפת תכנות רב-תכליתית וחזקה עבור תחומים שונים, כולל יישומי שולחן עבודה, פיתוח אתרים, אפליקציות לנייד ופיתוח משחקים באמצעות טכנולוגיות כמו Unity. ככל שתתקדם במסע שלך ב-C#, תוכל לחקור נושאים מתקדמים יותר כגון ירושה, פולימורפיזם, ממשקים, גנריות, LINQ (שאילתה משולבת בשפה) ותכנות אסינכרוני באמצעות משימות ואסינכרון/ממתין. הבנת המושגים הללו תשפר את יכולתך לעצב יישומים חזקים וניתנים להרחבה.

בואו נתחיל עם היסודות.

הגדרת סביבת הפיתוח

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

• התקן את Visual Studio: הורד והתקן את Visual Studio מהאתר הרשמי של Microsoft. Visual Studio היא סביבת פיתוח משולבת רבת עוצמה (IDE) המספקת את כל הכלים הדרושים לפיתוח C#.
• צור פרוייקט חדש: הפעל את Visual Studio וצור פרוייקט חדש. בחר את תבנית הפרויקט המתאימה בהתאם לסוג היישום שברצונך לבנות.
• כתוב קוד: לאחר הגדרת הפרוייקט שלך, תוכל להתחיל לכתוב קוד C# בעורך הקוד שסופק על ידי Visual Studio.

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

תוכנית שלום עולם

המסורתי "שלום, עולם!" תוכנית היא לעתים קרובות התוכנית הראשונה שאתה כותב בכל שפת תכנות. כך תוכל לכתוב את זה ב-C#:

using System;

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

בדוגמה זו, אנו כוללים תחילה את מרחב השמות 'System', המכיל מחלקה בשם 'Console', לטיפול בקלט ופלט. לאחר מכן, אנו מגדירים מחלקה בשם 'Program'. בתוך המחלקה הזו, יש לנו שיטת 'Main', שהיא נקודת הכניסה של תוכנית C#. לבסוף, אנו משתמשים בשיטת 'Console.WriteLine' כדי להדפיס את ה"שלום, עולם!" הודעה לקונסולה.

משתנים וסוגי נתונים

ב-C#, עליך להכריז על משתנים לפני שתוכל להשתמש בהם. משתנים מכילים ערכים מסוגי נתונים שונים. להלן כמה סוגי נתונים נפוצים ב-C#:

• 'int': מייצג מספרים שלמים (למשל, 10, -5, 0).
• 'double': מייצג מספרי נקודה צפה עם מקומות עשרוניים (למשל, 3.14, -0.5).
• 'bool': מייצג ערכים בוליאניים (נכון או לא נכון).
• 'string': מייצג רצף של תווים (למשל, "Hello", "C#").

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

int age = 25;
double pi = 3.14;
bool isStudent = true;
string name = "John";

int sum = age + 5;
double circleArea = pi * 2 * 2;
bool isAdult = age >= 18;

Console.WriteLine("Name: " + name);
Console.WriteLine("Age: " + age);
Console.WriteLine("Sum: " + sum);
Console.WriteLine("Circle Area: " + circleArea);
Console.WriteLine("Is Adult? " + isAdult);

בדוגמה זו, אנו מצהירים על משתנים 'age', 'pi', 'isStudent' ו-'name' עם ההתאמה שלהם סוגי מידע. אנו מבצעים כמה פעולות בסיסיות כמו חיבור, כפל והשוואה. שיטת 'Console.WriteLine' משמשת להצגת הערכים בקונסולה.

מערכים ואוספים

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

מערכים

מערך ב-C# הוא אוסף בגודל קבוע של אלמנטים מאותו סוג. הנה דוגמה:

int[] numbers = new int[5] { 1, 2, 3, 4, 5 };

בדוגמה זו, אנו מצהירים על מערך שלמים בשם 'numbers' בגודל של '5'. אנו מאתחלים את המערך עם הערכים שצוינו באמצעות הסוגרים המתולתלים '{}'. אתה יכול לגשת לאלמנטים בודדים של המערך באמצעות סימון אינדקס, החל מ-0. לדוגמה, 'numbers[0]' נותן לך את האלמנט הראשון.

אוספים

אוספים ב-C# מספקים יותר גמישות מאשר מערכים מכיוון שהם יכולים לגדול או להתכווץ באופן דינמי. C# מציעה סוגי אוסף שונים, כגון 'List<T>', 'Dictionary<TKey, TValue>' ו-'HashSet<T>'.

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

using System.Collections.Generic;

הנה דוגמה לשימוש באוסף 'List<T>':

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
names.Add("Charlie");

בדוגמה זו, אנו יוצרים רשימה של מחרוזות בשם 'names' באמצעות מחלקת האתחול 'List<T>'. אנו משתמשים בשיטת 'Add()' כדי להוסיף אלמנטים לרשימה.

'List<T>' מספק שיטות ומאפיינים שימושיים רבים לעבודה עם אוספים, כגון 'Count' כדי לקבל את מספר האלמנטים, 'Remove()' להסרה אלמנט, ו-'Contains()' כדי לבדוק אם קיים אלמנט.

איטרציה על מערכים ואוספים

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

int[] numbers = new int[] { 1, 2, 3, 4, 5 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

בדוגמה זו, אנו משתמשים בלולאה 'foreach' כדי לחזור על כל רכיב במערך 'numbers' וברשימה 'names' ולהדפיס אותם ל- הקונסולה.

בקרת זרימה

זרימת בקרה מאפשרת לך לקבל החלטות ולבצע בלוקים שונים של קוד על סמך תנאים. C# מספק מספר מבני זרימת בקרה, כולל הצהרות 'if', הצהרות 'switch' ולולאות.

'If'

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

int number = 10;

if (number > 0)
{
    Console.WriteLine("The number is positive.");
}
else if (number < 0)
{
    Console.WriteLine("The number is negative.");
}
else
{
    Console.WriteLine("The number is zero.");
}

בדוגמה זו, אנו בודקים את הערך של המשתנה 'number' באמצעות הסעיפים 'if', 'else if' ו-'else'. בהתאם למצב, ההודעה המתאימה תודפס.

'Switch'

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

int dayOfWeek = 2;
string dayName;

switch (dayOfWeek)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    // ...
    default:
        dayName = "Invalid day";
        break;
}

Console.WriteLine("Today is " + dayName + ".");

בדוגמה זו, אנו מקצים את שם היום על סמך הערך של 'dayOfWeek' באמצעות המשפט 'switch'. ההצהרות 'case' מציינות את הערכים האפשריים והמקרה 'default' מבוצע אם אף אחד מהמקרים לא תואם.

הצהרות לולאה

לולאות מאפשרות לך לבצע שוב ושוב גוש קוד עד לתנאי מסוים. C# מספק לולאות 'for', 'while' ו-'do-while'.

'For'

לולאה 'for' משמשת כאשר אתה יודע את מספר האיטרציות מראש. הנה דוגמה:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Iteration: " + i);
}

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

'While'

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

int count = 0;

while (count < 5)
{
    Console.WriteLine("Count: " + count);
    count++;
}

בדוגמה זו, הלולאה פועלת עד שהמשתנה 'count' מגיע ל-5.

'Do-While'

לולאה 'do-while' דומה ללולאת while, אבל התנאי נבדק בסוף, כך שהלולאה מופעלת לפחות פעם אחת. הנה דוגמה:

int num = 1;

do
{
    Console.WriteLine("Number: " + num);
    num++;
} while (num <= 5);

בדוגמה זו, הלולאה פועלת עד שהמשתנה 'num' אינו קטן יותר או שווה ל-5.

פונקציות

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

int Add(int a, int b)
{
    return a + b;
}

void Greet(string name)
{
    Console.WriteLine("Hello, " + name + "!");
}

int result = Add(5, 3);
Greet("Alice");

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

כיתות וחפצים

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

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void SayHello()
    {
        Console.WriteLine("Hello, my name is " + Name + " and I'm " + Age + " years old.");
    }
}

Person person = new Person();
person.Name = "John";
person.Age = 30;
person.SayHello();

בדוגמה זו, אנו מגדירים מחלקה 'Person' עם מאפיינים 'Name' ו-'Age' ושיטת 'SayHello'. לאחר מכן אנו יוצרים מופע של המחלקה 'Person' באמצעות מילת המפתח 'new' ומגדירים את המאפיינים שלה. לבסוף, אנו קוראים לשיטת 'SayHello' באובייקט 'person'.

מושגי תכנות מונחה עצמים (OOP).

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

יְרוּשָׁה

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

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

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

כימוס

Encapsulation הוא התרגול של חיבור נתונים ושיטות יחד בכיתה ושליטה בגישה שלהם. אתה יכול להשתמש במשנה גישה ('public', 'private', 'protected' וכו') כדי לציין את החשיפה של חברים. הנה דוגמה:

class Person
{
    private string name;

    public string GetName()
    {
        return name;
    }

    public void SetName(string newName)
    {
        name = newName;
    }
}

בדוגמה זו, השדה 'name' מובלע בתוך המחלקה 'Person' וניתן לגשת אליו רק דרך 'GetName' ו-* שיטות h81*.

רב צורתיות

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

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks.");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows.");
    }
}

בדוגמה זו, למחלקה 'Animal' יש שיטה וירטואלית 'MakeSound', אשר מחליפה אותה על ידי 'Dog' ו-'Cat' שיעורים. פולימורפיזם מאפשר לנו להתייחס למקרים של 'Dog' ו-'Cat' כאל מקרים של 'Animal' ולהתקשר ל-'MakeSound' שיטה עליהם.

טיפול חריג

טיפול בחריגים מאפשר לך לטפל בשגיאות זמן ריצה בחן. ב-C#, אתה יכול להשתמש בלוקים של 'try-catch' כדי לתפוס ולטפל בחריגים. הנה דוגמה:

try
{
    int result = 10 / 0;
    Console.WriteLine("Result: " + result);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Divide by zero error: " + ex.Message);
}
finally
{
    Console.WriteLine("Cleanup code goes here.");
}

בדוגמה זו, אנו מנסים לבצע חלוקה באפס, מה שזורק 'DivideByZeroException'. הקוד בתוך הבלוק 'try' מבוצע, ואם מתרחש חריג, הוא נתפס על ידי הבלוק 'catch'.

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

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

סיכום

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