InstruccionesStatements

Las acciones de un programa se expresan mediante instrucciones.The actions of a program are expressed using statements. C# admite varios tipos de instrucciones diferentes, varias de las cuales se definen en términos de instrucciones insertadas.C# supports several different kinds of statements, a number of which are defined in terms of embedded statements.

Un bloque permite que se escriban varias instrucciones en contextos donde se permite una única instrucción.A block permits multiple statements to be written in contexts where a single statement is allowed. Un bloque se compone de una lista de instrucciones escritas entre los delimitadores { y }.A block consists of a list of statements written between the delimiters { and }.

Las instrucciones de declaración se usan para declarar variables locales y constantes.Declaration statements are used to declare local variables and constants.

Las instrucciones de expresión se usan para evaluar expresiones.Expression statements are used to evaluate expressions. Las expresiones que pueden usarse como instrucciones incluyen invocaciones de método, asignaciones de objetos mediante el operador new, asignaciones mediante = y los operadores de asignación compuestos, operaciones de incremento y decremento mediante los operadores ++ y -- y expresiones await.Expressions that can be used as statements include method invocations, object allocations using the new operator, assignments using = and the compound assignment operators, increment and decrement operations using the ++ and -- operators and await expressions.

Las instrucciones de selección se usan para seleccionar una de varias instrucciones posibles para su ejecución en función del valor de alguna expresión.Selection statements are used to select one of a number of possible statements for execution based on the value of some expression. En este grupo están las instrucciones if y switch.In this group are the if and switch statements.

Las instrucciones de iteración se usan para ejecutar una instrucción insertada de forma repetida.Iteration statements are used to execute repeatedly an embedded statement. En este grupo están las instrucciones while, do, for y foreach.In this group are the while, do, for, and foreach statements.

Las instrucciones de salto se usan para transferir el control.Jump statements are used to transfer control. En este grupo están las instrucciones break, continue, goto, throw, return y yield.In this group are the break, continue, goto, throw, return, and yield statements.

La instrucción try... catch se usa para detectar excepciones que se producen durante la ejecución de un bloque, y la instrucción try... finally se usa para especificar el código de finalización que siempre se ejecuta, tanto si se ha producido una excepción como si no.The try...catch statement is used to catch exceptions that occur during execution of a block, and the try...finally statement is used to specify finalization code that is always executed, whether an exception occurred or not.

Las instrucciones checked y unchecked sirven para controlar el contexto de comprobación de desbordamiento para conversiones y operaciones aritméticas de tipo integral.The checked and unchecked statements are used to control the overflow-checking context for integral-type arithmetic operations and conversions.

La instrucción lock se usa para obtener el bloqueo de exclusión mutua para un objeto determinado, ejecutar una instrucción y, luego, liberar el bloqueo.The lock statement is used to obtain the mutual-exclusion lock for a given object, execute a statement, and then release the lock.

La instrucción using se usa para obtener un recurso, ejecutar una instrucción y, luego, eliminar dicho recurso.The using statement is used to obtain a resource, execute a statement, and then dispose of that resource.

A continuación se enumeran los tipos de instrucciones que se pueden usar y se proporciona un ejemplo de cada una.The following lists the kinds of statements that can be used, and provides an example for each.

  • Declaración de variable local:Local variable declaration:
static void Declarations(string[] args)
{
    int a;
    int b = 2, c = 3;
    a = 1;
    Console.WriteLine(a + b + c);
}
  • Declaración de constante local:Local constant declaration:
static void ConstantDeclarations(string[] args)
{
    const float pi = 3.1415927f;
    const int r = 25;
    Console.WriteLine(pi * r * r);
}
  • Instrucción de expresión:Expression statement:
static void Expressions(string[] args)
{
    int i;
    i = 123;                // Expression statement
    Console.WriteLine(i);   // Expression statement
    i++;                    // Expression statement
    Console.WriteLine(i);   // Expression statement
}
  • Instrucción if:if statement:
static void IfStatement(string[] args)
{
    if (args.Length == 0)
    {
        Console.WriteLine("No arguments");
    }
    else 
    {
        Console.WriteLine("One or more arguments");
    }
}
  • Instrucción switch:switch statement:
static void SwitchStatement(string[] args)
{
    int n = args.Length;
    switch (n) 
    {
        case 0:
            Console.WriteLine("No arguments");
            break;
        case 1:
            Console.WriteLine("One argument");
            break;
        default:
            Console.WriteLine($"{n} arguments");
            break;
    }
}
  • Instrucción while:while statement:
static void WhileStatement(string[] args)
{
    int i = 0;
    while (i < args.Length) 
    {
        Console.WriteLine(args[i]);
        i++;
    }
}
  • Instrucción do:do statement:
static void DoStatement(string[] args)
{
    string s;
    do 
    {
        s = Console.ReadLine();
        Console.WriteLine(s);
    } while (!string.IsNullOrEmpty(s));
}

  • Instrucción for:for statement:
static void ForStatement(string[] args)
{
    for (int i = 0; i < args.Length; i++) 
    {
        Console.WriteLine(args[i]);
    }
}
  • Instrucción foreach:foreach statement:
static void ForEachStatement(string[] args)
{
    foreach (string s in args) 
    {
        Console.WriteLine(s);
    }
}
  • Instrucción break:break statement:
static void BreakStatement(string[] args)
{
    while (true) 
    {
        string s = Console.ReadLine();
        if (string.IsNullOrEmpty(s)) 
            break;
        Console.WriteLine(s);
    }
}
  • Instrucción continue:continue statement:
static void ContinueStatement(string[] args)
{
    for (int i = 0; i < args.Length; i++) 
    {
        if (args[i].StartsWith("/")) 
            continue;
        Console.WriteLine(args[i]);
    }
}
  • Instrucción goto:goto statement:
static void GoToStatement(string[] args)
{
    int i = 0;
    goto check;
    loop:
    Console.WriteLine(args[i++]);
    check:
    if (i < args.Length) 
        goto loop;
}
  • Instrucción return:return statement:
static int Add(int a, int b) 
{
    return a + b;
}
static void ReturnStatement(string[] args)
{
   Console.WriteLine(Add(1, 2));
   return;
}
  • Instrucción yield:yield statement:
static System.Collections.Generic.IEnumerable<int> Range(int start, int end) 
{
    for (int i = start; i < end; i++) 
    {
        yield return i;
    }
    yield break;
}
static void YieldStatement(string[] args)
{
    foreach (int i in Range(-10,10)) 
    {
        Console.WriteLine(i);
    }
}
  • Instrucciones throw e instrucciones try:throw statements and try statements:
static double Divide(double x, double y) 
{
    if (y == 0) 
        throw new DivideByZeroException();
    return x / y;
}
static void TryCatch(string[] args) 
{
    try 
    {
        if (args.Length != 2) 
        {
            throw new InvalidOperationException("Two numbers required");
        }
        double x = double.Parse(args[0]);
        double y = double.Parse(args[1]);
        Console.WriteLine(Divide(x, y));
    }
    catch (InvalidOperationException e) 
    {
        Console.WriteLine(e.Message);
    }
    finally 
    {
        Console.WriteLine("Good bye!");
    }
}
  • Instrucciones checked y unchecked:checked and unchecked statements:
static void CheckedUnchecked(string[] args) 
{
    int x = int.MaxValue;
    unchecked 
    {
        Console.WriteLine(x + 1);  // Overflow
    }
    checked 
    {
        Console.WriteLine(x + 1);  // Exception
    }     
}
  • Instrucción lock:lock statement:
class Account
{
    decimal balance;
    private readonly object sync = new object();
    public void Withdraw(decimal amount) 
    {
        lock (sync) 
        {
            if (amount > balance) 
            {
                throw new Exception(
                    "Insufficient funds");
            }
            balance -= amount;
        }
    }
}
  • Instrucción using:using statement:
static void UsingStatement(string[] args) 
{
    using (TextWriter w = File.CreateText("test.txt")) 
    {
        w.WriteLine("Line one");
        w.WriteLine("Line two");
        w.WriteLine("Line three");
    }
}