Instructies (C#-programmeerhandleiding)

  • Artikel

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 instructieblok 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 #{0} is {1}. Circumference = {2:N2}",
                                    counter, radius, circumference);

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

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
Declaratie-instructies 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-instructies Expressie-instructies waarmee een waarde wordt berekend, moeten de waarde opslaan in een variabele.
Selectie-instructies Met selectie-instructies kunt u vertakken naar verschillende codesecties, afhankelijk van een of meer opgegeven voorwaarden. Zie de volgende onderwerpen voor meer informatie:
Iteratie-instructies 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 instructie 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. Zie Asynchrone programmering met asynchroon programmeren en wachten op meer informatie.
De yield return instructie Een iterator voert een aangepaste iteratie uit voor een verzameling, zoals een lijst of een matrix. Een iterator gebruikt de rendementsinstructie om elk element één voor één 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 instructie De vaste instructie voorkomt dat de garbagecollector een verplaatsbare variabele verplaatst. Zie vast voor meer informatie.
De lock instructie Met de vergrendelingsinstructie kunt u de toegang tot codeblokken beperken tot slechts één thread tegelijk. Zie Lock voor meer informatie.
Gelabelde instructies 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 instructie De lege instructie bestaat uit één puntkomma. Het doet niets en kan worden gebruikt op plaatsen waar een instructie is vereist, maar er hoeft geen actie te worden uitgevoerd.

Declaratie-instructies

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;

Expressie-instructies

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

// Error. Not  statement because no assignment:
//circ * 2;

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

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 instructies

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 instructieblokken

Instructieblokken kunnen worden genest, zoals wordt weergegeven 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 instructies

Als de compiler bepaalt dat de controlestroom in geen geval een bepaalde instructie kan bereiken, produceert het waarschuwing CS0162, zoals wordt weergegeven in het volgende voorbeeld:

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