Instrucciones (Guía de programación de C#)

Actualización: Julio de 2008

Las acciones que realiza un programa se expresan en instrucciones. Las acciones comunes incluyen la declaración de variables, la asignación de valores, la llamada a métodos, el recorrido en bucle de las colecciones y la creación de bifurcaciones a uno u otro bloque de código en función de una condición determinada. El orden en que se ejecutan las instrucciones en un programa se denomina flujo de control o flujo de ejecución. El flujo de control puede variar cada vez que se ejecuta un programa, dependiendo de cómo reacciona éste a la entrada que recibe en tiempo de ejecución.

Una instrucción puede estar compuesta por una única línea de código que finaliza en un punto y coma o por una serie de instrucciones de una línea incluidas en un bloque. Un bloque de instrucciones se encierra entre corchetes {} y puede contener bloques anidados. En el código siguiente se muestran dos ejemplos de instrucciones de una línea y un bloque de instrucciones de varias líneas:

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

Tipos de instrucciones

En la tabla siguiente se enumeran los diferentes tipos de instrucciones de C# y sus palabras clave asociadas, con vínculos a temas que incluyen más información:

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

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

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

// Error. Not a 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>();

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

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

Instrucciones incrustadas

Algunas instrucciones, incluidas do, while, for y foreach, siempre cuentan con instrucciones incrustadas a continuación. Esta instrucción incrustada puede ser una instrucción única o varias instrucciones encerradas entre corchetes {} en un bloque de instrucciones. Las instrucciones incrustadas de una línea también se pueden encerrar entre corchetes {}, tal como se muestra en el ejemplo siguiente:

// Recommended style. Embedded statement in a 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);

Una instrucción incrustada que no se encierra entre corchetes {} no puede ser una instrucción de declaración ni una instrucción con etiquetas. Esto se muestra en el ejemplo siguiente:

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

Coloque la instrucción incrustada en un bloque para corregir el error:

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

Bloques de instrucciones anidados

Los bloques de instrucciones pueden estar anidados, tal como se muestra en el código siguiente:

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

}
return "Not found.";

Instrucciones inalcanzables

Si el compilador determina que el flujo de control nunca puede alcanzar una instrucción determinada bajo ninguna circunstancia, generará la advertencia CS0162, tal como se muestra en el ejemplo siguiente:

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

Secciones relacionadas

• Palabras clave de instrucciones (Referencia de C#)

• Expresiones (Guía de programación de C#)

• Operadores (Guía de programación de C#)

Especificación del lenguaje C#

Para obtener más información, vea las siguientes secciones de Especificación del lenguaje C#.

• 1.5 Instrucciones

• 8 Instrucciones

Vea también

Conceptos

Guía de programación de C#

Historial de cambios