Delen via

Statements (C#-programmeerhandleiding)

De acties die een programma uitvoert, worden uitgedrukt in instructies. Veelvoorkomende acties zijn het declareren van variabelen, het toewijzen van waarden, het aanroepen van methoden, het doorlopen van verzamelingen en het vertakken van een of een ander codeblok, afhankelijk van een bepaalde voorwaarde. De volgorde waarin instructies in een programma worden uitgevoerd, wordt de stroom van het beheer of de uitvoeringsstroom genoemd. De controlestroom kan variëren telkens wanneer een programma wordt uitgevoerd, afhankelijk van hoe het programma reageert op invoer die het tijdens runtime ontvangt.

Een instructie kan bestaan uit één regel code die eindigt op een puntkomma of een reeks instructies met één regel in een blok. Een statementblok staat tussen {} vierkante haken en kan geneste blokken bevatten. De volgende code toont twee voorbeelden van instructies met één regel en een blok met meerdere regels:

    public static void Main()
    {
        // Declaration statement.
        int counter;

        // Assignment statement.
        counter = 1;

        // Error! This is an expression, not an expression statement.
        // counter + 1;

        // Declaration statements with initializers are functionally
        // equivalent to  declaration statement followed by assignment statement:
        int[] radii = [15, 32, 108, 74, 9]; // Declare and initialize an array.
        const double pi = 3.14159; // Declare and initialize  constant.

        // foreach statement block that contains multiple statements.
        foreach (int radius in radii)
        {
            // Declaration statement with initializer.
            double circumference = pi * (2 * radius);

            // Expression statement (method invocation). A single-line
            // statement can span multiple text lines because line breaks
            // are treated as white space, which is ignored by the compiler.
            System.Console.WriteLine($"Radius of circle #{counter} is {radius}. Circumference = {circumference:N2}");

            // Expression statement (postfix increment).
            counter++;
        } // End of foreach statement block
    } // End of Main method body.
} // End of SimpleStatements class.
/*
   Output:
    Radius of circle #1 = 15. Circumference = 94.25
    Radius of circle #2 = 32. Circumference = 201.06
    Radius of circle #3 = 108. Circumference = 678.58
    Radius of circle #4 = 74. Circumference = 464.96
    Radius of circle #5 = 9. Circumference = 56.55
*/

Typen verklaringen

De volgende tabel bevat de verschillende typen instructies in C# en de bijbehorende trefwoorden, met koppelingen naar onderwerpen met meer informatie:

Categorie C#-trefwoorden, notities
Declaratieverklaringen Een declaratie-instructie introduceert een nieuwe variabele of constante. Een variabeledeclaratie kan eventueel een waarde aan de variabele toewijzen. In een constante declaratie is de toewijzing vereist.
Expressie-verklaringen Expressie-instructies waarmee een waarde wordt berekend, moeten de waarde opslaan in een variabele.
Selectie-uitspraken Met selectie-instructies kunt u vertakken naar verschillende codesecties, afhankelijk van een of meer opgegeven voorwaarden. Zie de volgende onderwerpen voor meer informatie:
Iteratie-uitspraken Met iteratie-instructies kunt u verzamelingen zoals matrices doorlopen of dezelfde set instructies herhaaldelijk uitvoeren totdat aan een opgegeven voorwaarde wordt voldaan. Zie de volgende onderwerpen voor meer informatie:
Jump-instructies Jump-instructies dragen het besturingselement over naar een andere codesectie. Zie de volgende onderwerpen voor meer informatie:
Instructies voor het afhandelen van uitzonderingen Met uitzonderingsafhandelingsinstructies kunt u probleemloos herstellen van uitzonderlijke omstandigheden die zich tijdens de runtime voordoen. Zie de volgende onderwerpen voor meer informatie:
checked en unchecked Met de checked instructies unchecked kunt u opgeven of numerieke bewerkingen van het type integraal een overloop mogen veroorzaken wanneer het resultaat wordt opgeslagen in een variabele die te klein is om de resulterende waarde op te slaan.
De await-verklaring Als u een methode markeert met de asynchrone wijziging, kunt u de wachtoperator in de methode gebruiken. Wanneer het besturingselement een await expressie in de asynchrone methode bereikt, keert het besturingselement terug naar de aanroeper en wordt de voortgang in de methode opgeschort totdat de wachtende taak is voltooid. Wanneer de taak is voltooid, kan de uitvoering worden hervat in de methode.

Zie de sectie Async-methoden van Methoden voor een eenvoudig voorbeeld. Voor meer informatie, zie Asynchrone programmering met async en await.
De yield return-verklaring Een iterator voert een aangepaste iteratie uit voor een verzameling, zoals een lijst of een matrix. Een iterator gebruikt de yield return-instructie om elk element een voor een te retourneren. Wanneer een yield return instructie is bereikt, wordt de huidige locatie in code onthouden. De uitvoering wordt opnieuw gestart vanaf die locatie wanneer de iterator de volgende keer wordt aangeroepen.

Zie Iterators voor meer informatie.
De fixed-verklaring De vaste instructie voorkomt dat de garbagecollector een verplaatsbare variabele verplaatst. Zie vast voor meer informatie.
De lock-verklaring Met de vergrendelingsinstructie kunt u de toegang tot codeblokken beperken tot slechts één thread tegelijk. Voor meer informatie, zie lock.
Gelabelde verklaringen U kunt een instructie een label geven en vervolgens het trefwoord goto gebruiken om naar de gelabelde instructie te gaan. (Zie het voorbeeld in de volgende rij.)
De lege verklaring De lege opdracht bestaat uit slechts één puntkomma. Het doet niets en kan worden gebruikt op plaatsen waar een instructie is vereist, maar er hoeft geen actie te worden uitgevoerd.

Declaratieverklaringen

De volgende code toont voorbeelden van variabeledeclaraties met en zonder een initiële toewijzing en een constante declaratie met de benodigde initialisatie.

// Variable declaration statements.
double area;
double radius = 2;

// Constant declaration statement.
const double pi = 3.14159;

Uitdrukkingsverklaringen

In de volgende code ziet u voorbeelden van expressie-instructies, waaronder toewijzing, object maken met toewijzing en aanroepen van methoden.

// Expression statement (assignment).
area = 3.14 * (radius * radius);

// Expression statement (result discarded).
int x = 0;
x++;

// Expression statement (method invocation).
System.Console.WriteLine();

// Expression statement (new object creation).
System.Collections.Generic.List<string> strings =
    new System.Collections.Generic.List<string>();

De lege verklaring

In de volgende voorbeelden ziet u twee toepassingen voor een lege instructie:

void ProcessMessages()
{
    while (ProcessMessage())
        ; // Statement needed here.
}

void F()
{
    //...
    if (done) goto exit;
//...
exit:
    ; // Statement needed here.
}

Ingesloten verklaringen

Sommige instructies, bijvoorbeeld iteratie-instructies, hebben altijd een ingesloten instructie die hierop volgt. Deze ingesloten instructie kan één instructie of meerdere instructies {} tussen vierkante haken in een instructieblok zijn. Zelfs ingesloten instructies met één regel kunnen tussen {} vierkante haken worden geplaatst, zoals wordt weergegeven in het volgende voorbeeld:

// Recommended style. Embedded statement in  block.
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
{
    System.Console.WriteLine(s);
}

// Not recommended.
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
    System.Console.WriteLine(s);

Een ingesloten instructie die niet tussen {} vierkante haken staat, kan geen declaratie-instructie of een gelabelde instructie zijn. Dit wordt weergegeven in het volgende voorbeeld:

if(pointB == true)
    //Error CS1023:
    int radius = 5;

Plaats de ingesloten instructie in een blok om de fout op te lossen:

if (b == true)
{
    // OK:
    System.DateTime d = System.DateTime.Now;
    System.Console.WriteLine(d.ToLongDateString());
}

Geneste codeblokken

Statementblokken kunnen genest worden, zoals te zien is in de volgende code:

foreach (string s in System.IO.Directory.GetDirectories(
    System.Environment.CurrentDirectory))
{
    if (s.StartsWith("CSharp"))
    {
        if (s.EndsWith("TempFolder"))
        {
            return s;
        }
    }
}
return "Not found.";

Onbereikbare uitspraken

Als de compiler bepaalt dat de controlestroom in geen geval een bepaalde instructie kan bereiken, zal deze een waarschuwing CS0162 geven, zoals in het volgende voorbeeld wordt getoond.

// An over-simplified example of unreachable code.
const int val = 5;
if (val < 4)
{
    System.Console.WriteLine("I'll never write anything."); //CS0162
}

C#-taalspecificatie

Zie de sectie Instructies van de C#-taalspecificatie voor meer informatie.

Zie ook