Compartir a través de

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

Las acciones que realiza un programa se expresan en instrucciones . Entre las acciones comunes se incluyen la declaración de variables, la asignación de valores, la llamada a métodos, el bucle a través de colecciones y la 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 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 termina en punto y coma o 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:

    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 #{counter} is {radius}. Circumference = {circumference:N2}");

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

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

Categoría Palabras clave/notas de C#
Declaraciones Una instrucción de declaración introduce una variable o constante nueva. Opcionalmente, una declaración de variable puede asignar 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 bifurcar a diferentes secciones de código, en función de una o varias condiciones especificadas. Para obtener más información, consulte los temas siguientes:
Instrucciones de iteración Las instrucciones de iteración permiten recorrer colecciones como matrices o realizar el mismo conjunto de instrucciones repetidamente hasta que se cumpla una condición especificada. Para obtener más información, consulte los temas siguientes:
Instrucciones de salto Las instrucciones jump transfieren el control a otra sección de código. Para obtener más información, consulte los temas siguientes:
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, consulte los temas siguientes:
checked y unchecked Las instrucciones checked y unchecked le permiten especificar si las operaciones numéricas de tipo entero pueden causar un desbordamiento cuando el resultado se almacena en una variable demasiado pequeña para contener el valor resultante.
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 await expresión en el método asincrónico, el control vuelve al autor de la 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 cuando se llama al iterador la próxima vez.

Para más información, consulta Iteradores.
Instrucción fixed La instrucción fija impide que el recolector de basura reubique una variable móvil. Para obtener más información, consulte fixed.
Instrucción lock La instrucción lock permite limitar el acceso a bloques de código a solo un subproceso a la vez. Para obtener más información, consulte bloqueo.
Declaraciones etiquetadas Puede asignar una etiqueta a una instrucción y, a continuación, usar la palabra clave goto para saltar a la instrucción etiquetada. (Vea el ejemplo de la fila 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 donde se requiere una declaració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.

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

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

Instrucciones de expresión

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

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

// Expression statement (result discarded).
int x = 0;
x++;

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

// Expression statement (new object creation).
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 ProcessMessages()
{
    while (ProcessMessage())
        ; // Statement needed here.
}

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

Declaraciones integradas

Algunas instrucciones, por ejemplo, instrucciones de iteración, siempre tienen una instrucción insertada que las sigue. Esta instrucción insertada puede ser una sola instrucción o varias instrucciones entre {} corchetes 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:

// 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 insertada que no esté entre corchetes angulares {} no puede ser una instrucción de declaración ni una instrucción etiquetada. Esto se muestra en el ejemplo siguiente:

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

Coloque la instrucción insertada 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 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("TempFolder"))
        {
            return s;
        }
    }
}
return "Not found.";

Declaraciones inaccesibles

Si el compilador determina que el flujo de control nunca puede alcanzar una instrucción determinada en cualquier circunstancia, generará una advertencia CS0162, 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
}

Especificación del lenguaje C#

Para obtener más información, vea la sección Instrucciones de la especificación del lenguaje C#.

Consulte también