Hello World ב-C#: Main, Console.WriteLine ו-ReadLine

התוכנית הראשונה הקלאסית מדפיסה שורת טקסט אחת. ב-C# היא נראית כך:

using System;

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

פלט:

Hello, World!

שורה אחרי שורה

• using System; מאפשר לכתוב Console במקום השם המלא System.Console. Console היא מחלקה ב-namespace System (ראו namespaces ו-using).
• class Program מצהיר על מחלקה. כל קוד C# נמצא בתוך טיפוס; השם Program הוא מוסכמה, לא דרישה.
• static void Main() היא נקודת הכניסה. כשהתוכנית מתחילה, סביבת הריצה מחפשת מתודה סטטית בשם Main וקוראת לה. static אומר שהיא שייכת למחלקה עצמה, כך שלא צריך ליצור קודם אובייקט. void אומר שהיא לא מחזירה כלום.
• Console.WriteLine("Hello, World!"); קורא למתודה WriteLine עם ארגומנט מחרוזת. כל פקודה מסתיימת בנקודה-פסיק.
• הסוגריים המסולסלים { } מסמנים את הגוף של המחלקה ושל המתודה.

C# רגישה לאותיות גדולות וקטנות. console.writeline ו-main הם שמות שונים מ-Console.WriteLine ומ-Main, ואף אחד מהם לא קיים.

Console.WriteLine מול Console.Write

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

using System;

class Program
{
    static void Main()
    {
        Console.Write("Loading");
        Console.Write(".");
        Console.Write(".");
        Console.WriteLine(" done");

        Console.WriteLine(42);
        Console.WriteLine(true);
        Console.WriteLine();              // an empty line

        string item = "coffee";
        decimal price = 3.20m;
        Console.WriteLine("Item: " + item);             // concatenation
        Console.WriteLine($"{item} costs {price:F2}");   // interpolation
        Console.WriteLine("{0} costs {1:F2}", item, price); // composite format
    }
}

פלט:

Loading.. done
42
True

Item: coffee
coffee costs 3.20
coffee costs 3.20

שימו לב ש-true מודפס כ-True: זה מה ש-bool.ToString() מחזירה. הצורה $"...", שנקראת string interpolation, היא זו שתשתמשו בה הכי הרבה; ראו string interpolation לקודי העיצוב כמו :F2.

קריאת קלט עם Console.ReadLine

Console.ReadLine() מחכה שהמשתמש יקליד שורה וילחץ Enter, ואז מחזירה את השורה הזו כ-string בלי ירידת השורה. בסוף הקלט (למשל כשהקלט מנותב מקובץ שנגמר) היא מחזירה null.

// stdin: Maya\n27
using System;

class Program
{
    static void Main()
    {
        Console.Write("What is your name? ");
        string name = Console.ReadLine();

        Console.Write("How old are you? ");
        string ageText = Console.ReadLine();

        int age;
        if (int.TryParse(ageText, out age))
        {
            Console.WriteLine();
            Console.WriteLine($"Hi {name}, next year you will be {age + 1}.");
        }
        else
        {
            Console.WriteLine();
            Console.WriteLine($"'{ageText}' is not a number.");
        }
    }
}

פלט:

What is your name? How old are you? 
Hi Maya, next year you will be 28.

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

ReadLine תמיד מחזירה טקסט. כדי להשתמש בערך כמספר צריך להמיר אותו. int.Parse(text) זורקת FormatException כשהטקסט הוא לא מספר; int.TryParse מחזירה במקום זאת false, ולכן היא הבחירה הנכונה לקלט ממשתמש. הפרטים נמצאים ב-המרת טיפוסים.

שתי מתודות קשורות: Console.Read() מחזירה את התו הבא כקוד int, ו-Console.ReadKey() קוראת לחיצת מקש אחת בלי לחכות ל-Enter (היא עובדת רק בטרמינל אינטראקטיבי).

הצורות האחרות של המתודה Main

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

static void Main()
static void Main(string[] args)
static int Main()
static int Main(string[] args)
static async Task Main()             // C# 7.1 and later
static async Task<int> Main(string[] args)  // C# 7.1 and later

int שמוחזר הופך לקוד היציאה של התהליך, שסקריפטים ומערכות CI קוראים כדי להחליט אם התוכנית הצליחה (0 פירושו הצלחה לפי המוסכמה).

using System;

class Program
{
    static int Main(string[] args)
    {
        Console.WriteLine($"Got {args.Length} argument(s)");
        foreach (string arg in args)
        {
            Console.WriteLine("  " + arg);
        }
        return 0;
    }
}

פלט:

Got 0 argument(s)

הריצו את זה עם dotnet run -- apples pears ו-args יחזיק את "apples" ואת "pears". ה--- מפריד בין ארגומנטים לתוכנית שלכם לבין ארגומנטים לכלי dotnet.

הערות

ב-C# יש שלושה סוגי הערות. הקומפיילר מתעלם מכולם.

// A single-line comment runs to the end of the line.

/* A block comment
   can span several lines. */

/// <summary>
/// An XML documentation comment. Editors show it as the tooltip for the method.
/// </summary>
static decimal ApplyDiscount(decimal price) => price * 0.9m;

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

יצירה והרצה של פרויקט עם dotnet

במחשב שלכם, התקינו את ה-.NET SDK מ-dotnet.microsoft.com, ואז:

dotnet new console -o HelloApp
cd HelloApp
dotnet run

Hello, World!

dotnet new console יוצר שני קבצים: HelloApp.csproj (קובץ הפרויקט: framework יעד, הגדרות, הפניות לחבילות) ו-Program.cs. dotnet run מקמפל את הפרויקט ומריץ אותו. dotnet build מקמפל בלי להריץ וכותב את הפלט ל-bin/Debug/net8.0/ (שם התיקייה תלוי ב-framework היעד שלכם).

Top-level statements (C# 9 ואילך)

פתחו את Program.cs שנוצר ותמצאו בו את זה, ושום דבר אחר:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

זו תוכנית עם top-level statements, יכולת של C# 9. הקומפיילר מייצר את המחלקה Program ואת המתודה Main סביב הפקודות שלכם. גם using System; חסר, כי פרויקטים של .NET 6 ואילך מפעילים implicit usings: namespaces נפוצים כמו System, System.IO, System.Linq ו-System.Collections.Generic מיובאים לכל הפרויקט.

תוכניות top-level עדיין יכולות לקרוא את args, להשתמש ב-await ולבצע return של קוד יציאה:

// C# 9 and later: the whole Program.cs
Console.Write("Name: ");
string? name = Console.ReadLine();
Console.WriteLine($"Hello, {name}! You passed {args.Length} arguments.");
return 0;

רק קובץ אחד בפרויקט יכול להכיל top-level statements, וטיפוסים (מחלקות, records) חייבים לבוא אחריהם. ההערה string? היא nullable reference type (C# 8), והיא שם כי ReadLine יכולה להחזיר null. הצורה המפורשת עם class Program שמשמשת בדוגמאות בעמוד הזה שקולה, והיא מה שתראו בקוד ישן יותר וברוב הסקריפטים של Unity, ולכן כדאי לדעת לקרוא את שתיהן. העבירו --use-program-main ל-dotnet new console אם אתם מעדיפים את הצורה המפורשת בפרויקטים חדשים.

השגיאות שתראו ראשונות

• CS1002: ; expected. לפקודה חסרה נקודה-פסיק. השגיאה מדווחת בסוף השורה שחסרה לה.
• CS0103: The name 'console' does not exist in the current context. אותיות גדולות וקטנות שגויות, או using System; חסר בפרויקט בלי implicit usings.
• CS5001: Program does not contain a static 'Main' method suitable for an entry point. Main מאוית לא נכון, לא static, או שיש לה חתימה שאינה נתמכת.
• CS0017: Program has more than one entry point defined. בשתי מחלקות יש Main. השאירו אחת, או בחרו אחת עם ההגדרה StartupObject בקובץ ה-.csproj.
• החלון נסגר מיד. כשמפעילים אפליקציית console בלחיצה כפולה, החלון נסגר כש-Main חוזרת. הריצו אותה מטרמינל, או הוסיפו Console.ReadKey(); בסוף בזמן הבדיקות.