Statements (C# Programming Guide)

The actions that a program takes are expressed in statements. Common actions include declaring variables, assigning values, calling methods, looping through collections, and branching to one or another block of code, depending on a given condition. The order in which statements are executed in a program is called the flow of control or flow of execution. The flow of control may vary every time that a program is run, depending on how the program reacts to input that it receives at run time.

A statement can consist of a single line of code that ends in a semicolon, or a series of single-line statements in a block. A statement block is enclosed in {} brackets and can contain nested blocks. The following code shows two examples of single-line statements, and a multi-line statement block:

    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).
        } // End of foreach statement block
    } // End of Main method body.
} // End of SimpleStatements class.
    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

Types of statements

The following table lists the various types of statements in C# and their associated keywords, with links to topics that include more information:

Category C# keywords / notes
Declaration statements A declaration statement introduces a new variable or constant. A variable declaration can optionally assign a value to the variable. In a constant declaration, the assignment is required.
Expression statements Expression statements that calculate a value must store the value in a variable.
Selection statements Selection statements enable you to branch to different sections of code, depending on one or more specified conditions. For more information, see the following topics:
Iteration statements Iteration statements enable you to loop through collections like arrays, or perform the same set of statements repeatedly until a specified condition is met. For more information, see the following topics:
Jump statements Jump statements transfer control to another section of code. For more information, see the following topics:
Exception-handling statements Exception-handling statements enable you to gracefully recover from exceptional conditions that occur at run time. For more information, see the following topics:
checked and unchecked The checked and unchecked statements enable you to specify whether integral-type numerical operations are allowed to cause an overflow when the result is stored in a variable that is too small to hold the resulting value.
The await statement If you mark a method with the async modifier, you can use the await operator in the method. When control reaches an await expression in the async method, control returns to the caller, and progress in the method is suspended until the awaited task completes. When the task is complete, execution can resume in the method.

For a simple example, see the "Async Methods" section of Methods. For more information, see Asynchronous Programming with async and await.
The yield return statement An iterator performs a custom iteration over a collection, such as a list or an array. An iterator uses the yield return statement to return each element one at a time. When a yield return statement is reached, the current location in code is remembered. Execution is restarted from that location when the iterator is called the next time.

For more information, see Iterators.
The fixed statement The fixed statement prevents the garbage collector from relocating a movable variable. For more information, see fixed.
The lock statement The lock statement enables you to limit access to blocks of code to only one thread at a time. For more information, see lock.
Labeled statements You can give a statement a label and then use the goto keyword to jump to the labeled statement. (See the example in the following row.)
The empty statement The empty statement consists of a single semicolon. It does nothing and can be used in places where a statement is required but no action needs to be performed.

Declaration statements

The following code shows examples of variable declarations with and without an initial assignment, and a constant declaration with the necessary initialization.

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

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

Expression statements

The following code shows examples of expression statements, including assignment, object creation with assignment, and method invocation.

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

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

// Expression statement (method invocation).

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

The empty statement

The following examples show two uses for an empty statement:

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

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

Embedded statements

Some statements, for example, iteration statements, always have an embedded statement that follows them. This embedded statement may be either a single statement or multiple statements enclosed by {} brackets in a statement block. Even single-line embedded statements can be enclosed in {} brackets, as shown in the following example:

// Recommended style. Embedded statement in  block.
foreach (string s in System.IO.Directory.GetDirectories(

// Not recommended.
foreach (string s in System.IO.Directory.GetDirectories(

An embedded statement that is not enclosed in {} brackets cannot be a declaration statement or a labeled statement. This is shown in the following example:

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

Put the embedded statement in a block to fix the error:

if (b == true)
    // OK:
    System.DateTime d = System.DateTime.Now;

Nested statement blocks

Statement blocks can be nested, as shown in the following code:

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

Unreachable statements

If the compiler determines that the flow of control can never reach a particular statement under any circumstances, it will produce warning CS0162, as shown in the following example:

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

C# language specification

For more information, see the Statements section of the C# language specification.

See also