Dela via

Instruktioner (C#-programmeringsguide)

  • Artikel

De åtgärder som ett program vidtar uttrycks i instruktioner. Vanliga åtgärder är att deklarera variabler, tilldela värden, anropa metoder, loopa igenom samlingar och förgrena till ett eller annat kodblock, beroende på ett visst villkor. Den ordning i vilken instruktioner körs i ett program kallas flödet av kontroll eller körningsflöde. Kontrollflödet kan variera varje gång ett program körs, beroende på hur programmet reagerar på indata som det tar emot vid körning.

En instruktion kan bestå av en enda kodrad som slutar i ett semikolon eller en serie enradsinstruktioner i ett block. Ett instruktionsblock omges av {} hakparenteser och kan innehålla kapslade block. Följande kod visar två exempel på enradsinstruktioner och ett block med flera rader:

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

Typer av instruktioner

I följande tabell visas de olika typerna av instruktioner i C# och deras associerade nyckelord, med länkar till ämnen som innehåller mer information:

Kategori C#-nyckelord/anteckningar
Deklarationsuttryck En deklarationsinstruktor introducerar en ny variabel eller konstant. En variabeldeklaration kan om du vill tilldela variabeln ett värde. I en konstant deklaration krävs tilldelningen.
Uttrycksuttryck Uttrycksuttryck som beräknar ett värde måste lagra värdet i en variabel.
Urvalsuttryck Med urvalsuttryck kan du förgrena till olika kodavsnitt, beroende på ett eller flera angivna villkor. Mer information finns i följande avsnitt:
Iterationsinstruktioner Med iterationsinstruktioner kan du loopa igenom samlingar som matriser eller utföra samma uppsättning instruktioner upprepade gånger tills ett angivet villkor uppfylls. Mer information finns i följande avsnitt:
Jump-instruktioner Jump-instruktioner överför kontroll till ett annat kodavsnitt. Mer information finns i följande avsnitt:
Undantagshanteringsuttryck Med undantagshanteringsinstruktioner kan du återställa från exceptionella förhållanden som inträffar vid körning. Mer information finns i följande avsnitt:
checked och unchecked Med instruktionen checked och unchecked kan du ange om numeriska åtgärder av typen integral tillåts orsaka ett spill när resultatet lagras i en variabel som är för liten för att innehålla det resulterande värdet.
Instruktionen await Om du markerar en metod med asynkron modifierare kan du använda await-operatorn i -metoden. När kontrollen når ett await uttryck i asynkron metoden återgår kontrollen till anroparen och förloppet i metoden pausas tills den väntade aktiviteten har slutförts. När uppgiften är klar kan körningen återupptas i -metoden.

Ett enkelt exempel finns i avsnittet "Async Methods" (Asynkrona metoder) i Metoder. Mer information finns i Asynkron programmering med asynkron asynkron programmering och väntar.
Instruktionen yield return En iterator utför en anpassad iteration över en samling, till exempel en lista eller en matris. En iterator använder avkastningsreturinstrukturen för att returnera varje element ett i taget. När en yield return instruktion har nåtts sparas den aktuella platsen i koden. Körningen startas om från den platsen när iteratorn anropas nästa gång.

Mer information finns i Iteratorer.
Instruktionen fixed Den fasta instruktionen hindrar skräpinsamlaren från att flytta en flyttbar variabel. Mer information finns i Åtgärdat.
Instruktionen lock Med låssatsen kan du begränsa åtkomsten till kodblock till endast en tråd i taget. Mer information finns i lås.
Etiketterade instruktioner Du kan ge en instruktion en etikett och sedan använda nyckelordet goto för att hoppa till den märkta instruktionen. (Se exemplet på följande rad.)
Den tomma instruktionen Den tomma instruktionen består av ett enda semikolon. Den gör ingenting och kan användas på platser där en instruktion krävs, men ingen åtgärd behöver utföras.

Deklarationsuttryck

Följande kod visar exempel på variabeldeklarationer med och utan en inledande tilldelning och en konstant deklaration med nödvändig initiering.

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

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

Uttrycksuttryck

Följande kod visar exempel på uttrycksuttryck, inklusive tilldelning, objektskapande med tilldelning och metodanrop.

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

Den tomma instruktionen

Följande exempel visar två användningsområden för en tom instruktion:

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

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

Inbäddade instruktioner

Vissa instruktioner, till exempel iterationsinstruktioner, har alltid en inbäddad instruktion som följer dem. Den här inbäddade instruktionen kan vara antingen en enda instruktion eller flera instruktioner som omges av {} hakparenteser i ett instruktionsblock. Även inbäddade enradsinstruktioner kan omges {} av hakparenteser, som du ser i följande exempel:

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

En inbäddad instruktion som inte omges av {} hakparenteser kan inte vara en deklarationsuttryck eller en märkt instruktion. Detta visas i följande exempel:

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

Placera den inbäddade instruktionen i ett block för att åtgärda felet:

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

Kapslade instruktionsblock

Instruktionsblock kan kapslas, enligt följande kod:

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

Instruktioner som inte kan nås

Om kompilatorn fastställer att kontrollflödet aldrig kan nå en viss instruktion under några omständigheter, skapar den varnings-CS0162, som visas i följande exempel:

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

Språkspecifikation för C#

Mer information finns i avsnittet Instruktioner i C#-språkspecifikationen.

Se även