Compartir a través de


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.

Instrucciones de expresión

Las instrucciones de expresión que calculan un valor deben almacenar el valor en una variable.

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:

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

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#