Tipos de instrucciones

C# dispone de las siguientes categorías de instrucciones:

Las acciones que realiza un programa se expresan en instrucciones. Entre las acciones comunes se incluyen declarar variables, asignar valores, llamar a métodos, recorrer colecciones en bucle y crear una bifurcación a uno u otro bloque de código, en función de una condición determinada. El orden en el 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, en función de cómo reacciona el programa a la entrada que recibe en tiempo de ejecución.

Una instrucción puede constar de una sola línea de código que finaliza en un punto y coma o de una serie de instrucciones de una sola línea en un bloque. Un bloque de instrucciones se incluye entre llaves {} y puede contener bloques anidados. En el código siguiente se muestran dos ejemplos de instrucciones de una sola línea y un bloque de instrucciones de varias líneas:

    static void Main()
    {
        // Declaración.
        int contador;

        // Asignación de lo declarado.
        counter = 1;

        // Error! Esto es una expresión, no una declaración de expresión.
        // counter + 1;

        // Las declaraciones de declaración con inicializadores son funcionalmente
        // equivalente a la declaración de declaración seguida de la declaración de asignación:
        int[] radios = { 15, 32, 108, 74, 9 }; // Declare e inicialice un arreglo.
        const double pi = 3.14159; // Declare and inicialice la constante.

        // por cada bloque de declaración que contenga multiples declaraciones.
        foreach (int radio in radios)
        {
            // Declaración de sentencia con inicializador.
            double circunferencia = pi * (2 * radio);

            // Declaración de expresión (invocación de método). Una sola línea
            // la declaración puede abarcar varias líneas de texto porque los saltos de línea
            // se tratan como espacios en blanco, que el compilador ignora.
            System.Console.WriteLine("El radio del circulo #{0} is {1}. Circunferencia = {2:N2}",
                                    contador, redio, circunferencia);

            // Expression statement (postfix increment).
            contador++;
        } // Fin del bloque de instrucciones foreach
    } // Fin del cuerpo del método principal.
} // Fin de la clase SimpleStatements.
/*
   Salida:
    El radio del circulo #1 = 15. Circunferencia = 94.25
    El radio del circulo #2 = 32. Circunferencia = 201.06
    El radio del circulo #3 = 108. Circunferencia = 678.58
    El radio del circulo #4 = 74. Circunferencia = 464.96
    El radio del circulo #5 = 9. Circunferencia = 56.55
*/

Tipos de instrucciones

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

TIPOS DE INSTRUCCIONES

Categoría	Palabras clave de C# / notas
Instrucciones de declaración	Una instrucción de declaración introduce una variable o constante nueva. 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 colecciones, como matrices, o realizar el mismo conjunto de instrucciones repetidas veces hasta que se cumpla una condición especificada. Para obtener más información, vea los temas siguientes: do for foreach 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 para el control de excepciones	Las instrucciones para el control de excepciones permiten recuperarse correctamente de condiciones excepcionales producidas 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 que es demasiado pequeña para contener el valor resultante. Para obtener más información, vea checked y unchecked.
Instrucción await	Si marca un método con el modificador async , puede usar el operador await en el método. Cuando el control alcanza una expresión await en el método asincrónico, el control se devuelve al autor de llamada y el progreso del método se suspende hasta que se completa la tarea esperada. Cuando se completa la tarea, la ejecución puede reanudarse en el método. Para obtener un ejemplo sencillo, vea la sección "Métodos asincrónicos" de Métodos. Para obtener más información, vea Programación asincrónica con Async y Await.
Instrucción yield return	Un iterador realiza una iteración personalizada en una colección, como una lista o matriz. Un iterador utiliza la instrucción yield return para devolver cada elemento de uno en uno. Cuando se alcanza una instrucción yield return, se recuerda la ubicación actual en el código. La ejecución se reinicia desde esa ubicación la próxima vez que se llama el iterador. Para obtener más información, consulta Iteradores.
Instrucción fixed	La instrucción fixed impide que el recolector de elementos no utilizados cambie la ubicación de una variable móvil. Para obtener más información, vea fixed.
Instrucción lock	La instrucción lock permite limitar el acceso a bloques de código a un solo subproceso de cada vez. Para obtener más información, vea lock.
Instrucciones con etiqueta	Puede asignar una etiqueta a una instrucción y, después, usar la palabra clave goto para saltar a la instrucción con etiqueta. (Vea el ejemplo de la línea siguiente).
Instrucción vacía	La instrucción vacía consta únicamente de un punto y coma. No hace nada y se puede usar en lugares en los que se requiere una instrucción, pero no es necesario realizar ninguna acción.

Instrucciones de declaración

En el código siguiente se muestran ejemplos de declaraciones de variables con y sin una asignación inicial, y una declaración constante con la inicialización necesaria.

// Declaración de sentencia variable.
double area;
double radio = 2;

// Declaración de sentencia constante.
const double pi = 3.14159;

Instrucciones de expresión

En el código siguiente se muestran ejemplos de instrucciones de expresión, que incluyen la asignación, la creación de objetos con asignación y la invocación de método.

area = 3.14 * (radio * radio);

// Error. No hay sentencia porque no hay asignación:
//circ * 2;

// Expression statement (method invocation).
System.Console.WriteLine();

// Declaración de expresión (creación de un nuevo objeto).
System.Collections.Generic.List<string> strings =
    new System.Collections.Generic.List<string>();

Instrucción vacía

En los ejemplos siguientes se muestran dos usos de una instrucción vacía:

void ProcesarMensajes()
{
    while (ProcesarMensajes())
        ; // Sentencia aquí.
}

void F()
{
    //...
    if (terminado) goto exit;
//...
exit:
    ; // Sentencia aquí.
}

Instrucciones insertadas

Algunas instrucciones, por ejemplo, las instrucciones de iteración, siempre van seguidas de una instrucción insertada. Esta instrucción insertada puede ser una sola instrucción o varias instrucciones incluidas entre llaves {} en un bloque de instrucciones. Las instrucciones insertadas de una sola línea también pueden ir entre llaves {}, como se muestra en el siguiente ejemplo:

// Estilo recomendado. Declaración incorporada en bloque.
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
{
    System.Console.WriteLine(s);
}

// No recomendado.
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
    System.Console.WriteLine(s);

Una instrucción insertada que no está incluida entre llaves {} no puede ser una instrucción de declaración o una instrucción con etiqueta. Esto se muestra en el ejemplo siguiente:

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

Coloque la instrucción insertada en un bloque para solucionar el error:

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

Bloques de instrucciones anidadas

Los bloques de instrucciones pueden anidarse, 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("FolderTemporal"))
        {
            return s;
        }
    }
}
return "No Encontrado.";

Instrucciones inaccesibles

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

// Un ejemplo simplificado de código inalcanzable.
const int val = 5;
if (val < 4)
{
    System.Console.WriteLine("Nunca escribiré nada!."); //CS0162
}