InstruçõesStatements

As ações de um programa são expressas usando instruções.The actions of a program are expressed using statements. O C# oferece suporte a vários tipos diferentes de instruções, algumas delas definidas em termos de instruções inseridas.C# supports several different kinds of statements, a number of which are defined in terms of embedded statements.

Um bloco permite a produção de várias instruções em contextos nos quais uma única instrução é permitida.A block permits multiple statements to be written in contexts where a single statement is allowed. Um bloco é composto por uma lista de instruções escritas entre os delimitadores { e }.A block consists of a list of statements written between the delimiters { and }.

Instruções de declaração são usadas para declarar constantes e variáveis locais.Declaration statements are used to declare local variables and constants.

Instruções de expressão são usadas para avaliar expressões.Expression statements are used to evaluate expressions. As expressões que podem ser usadas como instruções incluem chamadas de método, alocações de objeto usando o operador new, atribuições usando = e os operadores de atribuição compostos, operações de incremento e decremento usando os operadores ++ e -- e as expressões 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.

Instruções de seleção são usadas para selecionar uma dentre várias instruções possíveis para execução com base no valor de alguma expressão.Selection statements are used to select one of a number of possible statements for execution based on the value of some expression. Neste grupo estão as instruções if e switch.In this group are the if and switch statements.

Instruções de iteração são usadas para executar repetidamente uma instrução inserida.Iteration statements are used to execute repeatedly an embedded statement. Neste grupo estão as instruções while, do, for e foreach.In this group are the while, do, for, and foreach statements.

Instruções de salto são usadas para transferir o controle.Jump statements are used to transfer control. Neste grupo estão as instruções break, continue, goto, throw, return e yield.In this group are the break, continue, goto, throw, return, and yield statements.

A instrução try... catch é usada para capturar exceções que ocorrem durante a execução de um bloco, e a instrução try... finally é usada para especificar o código de finalização que é executado sempre, se uma exceção ocorrer ou não.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.

As instruções checked e unchecked são usadas para controlar o contexto de verificação de estouro para operações e conversões aritméticas do tipo integral.The checked and unchecked statements are used to control the overflow-checking context for integral-type arithmetic operations and conversions.

A instrução lock é usada para obter o bloqueio de exclusão mútua para um determinado objeto, executar uma instrução e, em seguida, liberar o bloqueio.The lock statement is used to obtain the mutual-exclusion lock for a given object, execute a statement, and then release the lock.

A instrução using é usada para obter um recurso, executar uma instrução e, em seguida, descartar esse recurso.The using statement is used to obtain a resource, execute a statement, and then dispose of that resource.

A lista a seguir contém os tipos de instruções que podem ser usados, e fornece um exemplo para cada um.The following lists the kinds of statements that can be used, and provides an example for each.

  • Declaração de variável local:Local variable declaration:
static void Declarations(string[] args)
{
    int a;
    int b = 2, c = 3;
    a = 1;
    Console.WriteLine(a + b + c);
}
  • Declaração constante local:Local constant declaration:
static void ConstantDeclarations(string[] args)
{
    const float pi = 3.1415927f;
    const int r = 25;
    Console.WriteLine(pi * r * r);
}
  • Instrução de expressão: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
}
  • Instrução if:if statement:
static void IfStatement(string[] args)
{
    if (args.Length == 0)
    {
        Console.WriteLine("No arguments");
    }
    else 
    {
        Console.WriteLine("One or more arguments");
    }
}
  • Instrução 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;
    }
}
  • Instrução while:while statement:
static void WhileStatement(string[] args)
{
    int i = 0;
    while (i < args.Length) 
    {
        Console.WriteLine(args[i]);
        i++;
    }
}
  • Instrução do:do statement:
static void DoStatement(string[] args)
{
    string s;
    do 
    {
        s = Console.ReadLine();
        Console.WriteLine(s);
    } while (!string.IsNullOrEmpty(s));
}

  • Instrução for:for statement:
static void ForStatement(string[] args)
{
    for (int i = 0; i < args.Length; i++) 
    {
        Console.WriteLine(args[i]);
    }
}
  • Instrução foreach:foreach statement:
static void ForEachStatement(string[] args)
{
    foreach (string s in args) 
    {
        Console.WriteLine(s);
    }
}
  • Instrução break:break statement:
static void BreakStatement(string[] args)
{
    while (true) 
    {
        string s = Console.ReadLine();
        if (string.IsNullOrEmpty(s)) 
            break;
        Console.WriteLine(s);
    }
}
  • Instrução 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]);
    }
}
  • Instrução 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;
}
  • Instrução return:return statement:
static int Add(int a, int b) 
{
    return a + b;
}
static void ReturnStatement(string[] args)
{
   Console.WriteLine(Add(1, 2));
   return;
}
  • Instrução 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);
    }
}
  • Instruções throw e instruções 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!");
    }
}
  • Instruções checked e 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
    }     
}
  • Instrução 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;
        }
    }
}
  • Instrução 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");
    }
}