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

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

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:

Categoría	Palabras clave de C# / notas
Instrucciones de declaración	Una instrucción de declaración introduce una nueva variable o constante. Una declaración de variable puede asignar opcionalmente un valor a la variable. En una declaración de constante, se requiere la asignación. // Variable declaration statements. double area; double radius = 2; // Constant declaration statement. const double pi = 3.14159;
Instrucciones de expresión	Las instrucciones de expresión que calculan un valor deben almacenar el valor en una variable. // 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>();
Instrucciones de selección	Las instrucciones de selección permiten crear bifurcaciones a diferentes secciones de código, en función de una o varias condiciones especificadas. Para obtener más información, vea los temas siguientes: if, else, switch, case
Instrucciones de iteración	Las instrucciones de iteración permiten recorrer en bucle las colecciones como las matrices o bien realizar el mismo conjunto de instrucciones repetidamente hasta que se cumpla una condición especificada. Para obtener más información, vea los temas siguientes: do, for, foreach, in, while
Instrucciones de salto	Las instrucciones de salto transfieren el control a otra sección de código. Para obtener más información, vea los temas siguientes: break, continue, default, goto, return, yield
Instrucciones de control de excepciones	Las instrucciones de control de excepciones permiten recuperarse correctamente de condiciones excepcionales que se producen en tiempo de ejecución. Para obtener más información, vea los temas siguientes: throw, try-catch, try-finally, try-catch-finally
Checked y unchecked	Las instrucciones checked y unchecked permiten especificar si las operaciones numéricas pueden producir un desbordamiento cuando el resultado se almacena en una variable demasiado pequeña para contener el valor resultante. Para obtener más información, vea checked y unchecked.
Instrucción fixed	La instrucción fixed evita que el recolector de elementos no utilizados vuelva a ubicar una variable móvil. Para obtener más información, vea fixed.
Instrucción lock	La instrucción lock permite limitar el acceso a los bloques de código a solo un subproceso a la vez. Para obtener más información, vea lock.
Instrucciones con etiquetas	Puede asignar una etiqueta a una instrucción y, a continuación, utilizar la palabra clave goto para saltar a la instrucción con la etiqueta. (Vea el ejemplo de la fila siguiente.)
Instrucción vacía	La instrucción vacía está compuesta solo por un punto y coma. No hace nada y se puede utilizar en lugares donde se requiere una instrucción pero no es necesario realizar ninguna acción. En los ejemplos siguientes se muestran dos usos de una instrucción vacía: 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  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(pointB == 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 la Especificación del lenguaje C#. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.

Vea también

Conceptos

Guía de programación de C#