Delen via

Algemene structuur van een C#-programma

C#-programma's bestaan uit een of meer bestanden. Elk bestand bevat nul of meer naamruimten. Een naamruimte bevat typen, zoals klassen, structs, interfaces, opsommingen en gemachtigden of andere naamruimten. Het volgende voorbeeld is het skelet van een C#-programma dat al deze elementen bevat.

using System;

Console.WriteLine("Hello world!");

namespace YourNamespace
{
    class YourClass
    {
    }

    struct YourStruct
    {
    }

    interface IYourInterface
    {
    }

    delegate int YourDelegate();

    enum YourEnum
    {
    }

    namespace YourNestedNamespace
    {
        struct YourStruct
        {
        }
    }
}

In het voorgaande voorbeeld worden instructies op het hoogste niveau voor het toegangspunt van het programma gebruikt. Slechts één bestand kan instructies op het hoogste niveau bevatten. Het toegangspunt van het programma is de eerste tekstregel van de programmatekst in dat bestand. In dit geval is het de Console.WriteLine("Hello world!");. U kunt ook een statische methode maken met de naam Main als toegangspunt van het programma, zoals wordt weergegeven in het volgende voorbeeld:

// 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 dat geval begint het programma bij de openende accolade van de methode Main, namelijk Console.WriteLine("Hello world!");.

C#-programma's bouwen en uitvoeren

C# is een gecompileerde taal. In de meeste C#-programma's gebruikt u de dotnet build opdracht om een groep bronbestanden te compileren in een binair pakket. Vervolgens gebruikt u de dotnet run opdracht om het programma uit te voeren. (U kunt dit proces vereenvoudigen omdat dotnet run het programma wordt gecompileerd voordat u het indien nodig uitvoert.) Deze hulpprogramma's ondersteunen een uitgebreide taal van configuratieopties en opdrachtregelopties. De dotnet opdrachtregelinterface (CLI), die is opgenomen in de .NET SDK, biedt veel hulpprogramma's voor het genereren en wijzigen van C#-bestanden.

Vanaf C# 14 en .NET 10 kunt u op bestanden gebaseerde apps maken, wat het bouwen en uitvoeren van C#-programma's vereenvoudigt. U gebruikt de dotnet run opdracht om een programma uit te voeren dat zich in één *.cs bestand bevindt. Als het volgende codefragment bijvoorbeeld is opgeslagen in een bestand met de naam hello-world.cs, kunt u dit uitvoeren door het volgende te typen dotnet run hello-world.cs:

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

De eerste regel van het programma bevat de #! reeks voor Unix-shells. De locatie van de dotnet CLI kan variëren op verschillende distributies. Als u op elk Unix-systeem de machtiging uitvoeren (+x) voor een C#-bestand instelt, kunt u het C#-bestand uitvoeren vanaf de opdrachtregel:

./hello-world.cs

De bron voor deze programma's moet één bestand zijn, maar anders is alle C#-syntaxis geldig. U kunt op bestanden gebaseerde apps gebruiken voor kleine opdrachtregelprogramma's, prototypen of andere experimenten. op bestanden gebaseerde apps staan preprocessorrichtlijnen toe die het buildsysteem configureren.

Expressies en uitspraken

C#-programma's worden gebouwd met expressies en instructies. Expressies produceren een waarde en instructies voeren een actie uit:

Een expressie is een combinatie van waarden, variabelen, operators en methodeaanroepen die één waarde evalueren. Expressies produceren een resultaat en kunnen worden gebruikt waar een waarde wordt verwacht. De volgende voorbeelden zijn expressies:

  • 42 (letterlijke waarde)
  • x + y (rekenkundige bewerking)
  • Math.Max(a, b) (methode-aanroep)
  • condition ? trueValue : falseValue (voorwaardelijke expressie)
  • new Person("John") (object aanmaken)

Een instructie is een volledige instructie waarmee een actie wordt uitgevoerd. Instructies retourneren geen waarden; In plaats daarvan beheren ze de programmastroom, declareren ze variabelen of voeren ze bewerkingen uit. De volgende voorbeelden zijn uitspraken:

  • int x = 42; verklaring
  • Console.WriteLine("Hello"); (expressie-instructie - verpakt een expressie voor methode-aanroep)
  • if (condition) { /* code */ } (voorwaardelijke verklaring)
  • return result; (retourinstructie)

Het belangrijkste onderscheid: expressies evalueren waarden, terwijl instructies acties uitvoeren. Sommige constructies, zoals methode-aanroepen, kunnen beide zijn. Bijvoorbeeld, Math.Max(a, b) is een expressie wanneer het wordt gebruikt in int result = Math.Max(a, b);, maar wordt een expressie-instructie wanneer het alleen wordt geschreven als Math.Max(a, b);.

Zie Verklaringen voor gedetailleerde informatie over verklaringen. Zie Expressie-gebaseerde leden en andere expressiefuncties voor informatie over expressie-gebaseerde leden en andere expressiefuncties.

U leert meer over deze programma-elementen in de typen sectie van de basishandleiding:

C#-taalspecificatie

Zie Basisconcepten in de C#-taalspecificatievoor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

  • Last updated on