Hello World in C#: il primo programma, Main, Console.WriteLine e ReadLine

Il classico primo programma stampa una riga di testo. In C# è così:

using System;

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

Output:

Hello, World!

Riga per riga

• using System; ti permette di scrivere Console invece del nome completo System.Console. Console è una classe del namespace System (vedi namespace e using).
• class Program dichiara una classe. Tutto il codice C# sta dentro un tipo; il nome Program è una convenzione, non un obbligo.
• static void Main() è il punto di ingresso. All'avvio del programma, il runtime cerca un metodo statico chiamato Main e lo chiama. static significa che appartiene alla classe stessa, quindi non serve creare prima un oggetto. void significa che non restituisce niente.
• Console.WriteLine("Hello, World!"); chiama il metodo WriteLine con un argomento stringa. Ogni istruzione termina con un punto e virgola.
• Le graffe { } delimitano il corpo della classe e del metodo.

C# distingue tra maiuscole e minuscole. console.writeline e main sono nomi diversi da Console.WriteLine e Main, e nessuno dei due esiste.

Console.WriteLine e Console.Write

WriteLine aggiunge un a capo dopo il testo. Write no, quindi l'output successivo continua sulla stessa riga. Entrambi accettano qualsiasi tipo, non solo stringhe: numeri, booleani e oggetti vengono convertiti con il loro metodo 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
    }
}

Output:

Loading.. done
42
True

Item: coffee
coffee costs 3.20
coffee costs 3.20

Nota che true viene stampato come True: è quello che restituisce bool.ToString(). La forma $"...", chiamata interpolazione di stringhe, è quella che userai di più; vedi interpolazione di stringhe per i codici di formato come :F2.

Leggere l'input con Console.ReadLine

Console.ReadLine() aspetta che l'utente scriva una riga e prema Invio, poi restituisce quella riga come string senza l'a capo. Alla fine dell'input (per esempio quando l'input è rediretto da un file che è finito) restituisce 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.");
        }
    }
}

Output:

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

Quando lo esegui in un terminale, il testo che scrivi compare dopo ogni richiesta. L'output qui sopra non contiene testo digitato perché l'input è stato rediretto (passato tramite pipe) invece che digitato, quindi compare solo quello che scrive il programma.

ReadLine restituisce sempre testo. Per usare il valore come numero devi convertirlo. int.Parse(text) lancia una FormatException quando il testo non è un numero; int.TryParse invece restituisce false, ed è per questo che è la scelta giusta per l'input dell'utente. I dettagli sono in conversione di tipo.

Due metodi collegati: Console.Read() restituisce il carattere successivo come codice int, e Console.ReadKey() legge la pressione di un singolo tasto senza aspettare Invio (funziona solo in un terminale interattivo).

Le altre forme del metodo Main

Main può ricevere gli argomenti della riga di comando e può restituire un codice di uscita. Questi sono tutti punti di ingresso validi:

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

Un int restituito diventa il codice di uscita del processo, che script e sistemi di CI leggono per capire se il programma è andato a buon fine (per convenzione 0 significa successo).

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;
    }
}

Output:

Got 0 argument(s)

Eseguilo con dotnet run -- apples pears e args conterrà "apples" e "pears". Il -- separa gli argomenti per il tuo programma da quelli per lo strumento dotnet.

Commenti

C# ha tre tipi di commenti. Il compilatore li ignora tutti.

// 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;

Usa // per le note dentro il codice. I commenti /// vanno sui tipi e sui membri pubblici; l'IDE li mostra quando passi il mouse su una chiamata, e il compilatore può esportarli in un file XML per gli strumenti di documentazione.

Creare ed eseguire un progetto con dotnet

Sulla tua macchina, installa il .NET SDK da dotnet.microsoft.com, poi:

dotnet new console -o HelloApp
cd HelloApp
dotnet run

Hello, World!

dotnet new console crea due file: HelloApp.csproj (il file di progetto: framework di destinazione, impostazioni, riferimenti ai pacchetti) e Program.cs. dotnet run compila il progetto e lo esegue. dotnet build compila senza eseguire e scrive l'output in bin/Debug/net8.0/ (il nome della cartella segue il tuo framework di destinazione).

Istruzioni di primo livello (C# 9 e successivi)

Apri il Program.cs generato e troverai questo, e nient'altro:

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

Questo è un programma con istruzioni di primo livello (top-level statements), una funzionalità di C# 9. Il compilatore genera la classe Program e il metodo Main attorno alle tue istruzioni. Manca anche using System; perché i progetti .NET 6 e successivi attivano gli using impliciti: i namespace comuni come System, System.IO, System.Linq e System.Collections.Generic sono importati per tutto il progetto.

I programmi con istruzioni di primo livello possono comunque leggere args, usare await e restituire un codice di uscita con 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;

Solo un file per progetto può contenere istruzioni di primo livello, e i tipi (classi, record) devono venire dopo di esse. L'annotazione string? è un tipo riferimento nullable (C# 8), ed è lì perché ReadLine può restituire null. La forma esplicita class Program usata negli esempi di questa pagina è equivalente ed è quella che troverai nel codice più vecchio e nella maggior parte degli script Unity, quindi vale la pena saperle leggere entrambe. Passa --use-program-main a dotnet new console se nei nuovi progetti preferisci la forma esplicita.

I primi errori che vedrai

• CS1002: ; expected. A un'istruzione manca il punto e virgola. L'errore viene segnalato alla fine della riga in cui manca.
• CS0103: The name 'console' does not exist in the current context. Maiuscole sbagliate, oppure manca using System; in un progetto senza using impliciti.
• CS5001: Program does not contain a static 'Main' method suitable for an entry point. Main è scritto male, non è static o ha una firma non supportata.
• CS0017: Program has more than one entry point defined. Due classi hanno ciascuna un Main. Tienine uno, oppure scegline uno con l'impostazione StartupObject nel .csproj.
• La finestra si chiude subito. Quando un'app console viene avviata con un doppio clic, la finestra si chiude quando Main termina. Eseguila da un terminale, oppure aggiungi Console.ReadKey(); alla fine mentre fai i test.