Condividi tramite

Struttura generale di un programma C#

I programmi C# sono costituiti da uno o più file. Ogni file contiene zero o più namespace. Uno spazio dei nomi contiene tipi quali classi, struct, interfacce, enumerazioni e delegati o altri spazi dei nomi. L'esempio seguente è lo scheletro di un programma C# che contiene tutti questi elementi.

using System;

Console.WriteLine("Hello world!");

namespace YourNamespace
{
    class YourClass
    {
    }

    struct YourStruct
    {
    }

    interface IYourInterface
    {
    }

    delegate int YourDelegate();

    enum YourEnum
    {
    }

    namespace YourNestedNamespace
    {
        struct YourStruct
        {
        }
    }
}

L'esempio precedente utilizza istruzioni di primo livello come punto di ingresso del programma. Solo un file può avere istruzioni di primo livello. Il punto di ingresso del programma è la prima riga di testo del programma in tale file. In questo caso, è il Console.WriteLine("Hello world!");. È anche possibile creare un metodo statico denominato Main come punto di ingresso del programma, come illustrato nell'esempio seguente:

// A skeleton of a C# program
using System;
namespace YourNamespace
{
    class YourClass
    {
    }

    struct YourStruct
    {
    }

    interface IYourInterface
    {
    }

    delegate int YourDelegate();

    enum YourEnum
    {
    }

    namespace YourNestedNamespace
    {
        struct YourStruct
        {
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world!");
        }
    }
}

In tal caso il programma inizia nella parentesi graffa di apertura del Main metodo, che è Console.WriteLine("Hello world!");

Compilazione ed esecuzione di programmi C#

C# è un linguaggio compilato . Nella maggior parte dei programmi C# si usa il dotnet build comando per compilare un gruppo di file di origine in un pacchetto binario. Usare quindi il dotnet run comando per eseguire il programma. È possibile semplificare questo processo perché dotnet run compila il programma prima di eseguirlo, se necessario. Questi strumenti supportano un linguaggio completo di opzioni di configurazione e opzioni della riga di comando. L'interfaccia dotnet della riga di comando, inclusa in .NET SDK, offre molti strumenti per generare e modificare i file C#.

A partire da C# 14 e .NET 10, è possibile creare app basate su file, semplificando la compilazione e l'esecuzione di programmi C#. Usare il dotnet run comando per eseguire un programma contenuto in un singolo *.cs file. Ad esempio, se il frammento di codice seguente viene archiviato in un file denominato hello-world.cs, è possibile eseguirlo digitando dotnet run hello-world.cs:

#!/usr/bin/env dotnet
Console.WriteLine("Hello, World!");

La prima riga del programma contiene la #! sequenza per le shell Unix. La posizione del dotnet CLI può variare a seconda della distribuzione. In qualsiasi sistema Unix, se si imposta l'autorizzazione execute (+x) per un file C#, è possibile eseguire il file C# dalla riga di comando:

./hello-world.cs

L'origine di questi programmi deve essere un singolo file, ma in caso contrario tutta la sintassi C# è valida. È possibile usare app basate su file per piccole utilità della riga di comando, prototipi o altri esperimenti. Le app basate su file consentono direttive del preprocessore che configurano il sistema di compilazione.

Espressioni e istruzioni

I programmi C# vengono compilati usando espressioni e istruzioni. Le espressioni producono un valore e le istruzioni eseguono un'azione:

Un'espressione è una combinazione di valori, variabili, operatori e chiamate al metodo che restituiscono un singolo valore. Le espressioni producono un risultato e possono essere usate ovunque sia previsto un valore. Gli esempi seguenti sono espressioni:

  • 42 (valore letterale)
  • x + y (operazione aritmetica)
  • Math.Max(a, b) (chiamata al metodo)
  • condition ? trueValue : falseValue (espressione condizionale)
  • new Person("John") (creazione di oggetti)

Un'istruzione è un'istruzione completa che esegue un'azione. Le istruzioni non restituiscono valori; controllano invece il flusso del programma, dichiarano variabili o eseguono operazioni. Gli esempi seguenti sono affermazioni:

  • int x = 42; (dichiarazione)
  • Console.WriteLine("Hello"); (istruzione di espressione - incapsula un'espressione di chiamata al metodo)
  • if (condition) { /* code */ } (istruzione condizionale)
  • return result; (istruzione di ritorno)

La distinzione principale: le espressioni restituiscono valori, mentre le istruzioni eseguono azioni. Alcuni costrutti, ad esempio le chiamate al metodo, possono essere entrambi contemporaneamente. Ad esempio, Math.Max(a, b) è un'espressione quando viene usata in int result = Math.Max(a, b);, ma diventa un'istruzione di espressione quando viene scritta da sola come Math.Max(a, b);.

Per informazioni dettagliate sulle dichiarazioni, consultare Dichiarazioni. Per informazioni sui membri con corpo espressione e altre funzionalità di espressione, vedere Membri con corpo espressione.

Nella sezione tipi della guida ai concetti fondamentali, si apprende su questi elementi del programma:

Specifica del linguaggio C#

Per altre informazioni, vedere Concetti di base nella specifica del linguaggio C# . La specifica del linguaggio è l'origine definitiva per la sintassi e l'utilizzo di C#.

  • Last updated on