Share via

Instruções (guia de programação translation from VPE for Csharp)

  • Artigo

As ações que leva um programa são expressas em instruções.Ações comuns incluem Declarando variáveis, atribuindo valores, chamar métodos, loop pelas coleções e a ramificação a um ou outro bloco de código, dependendo de uma determinada condição.A ordem na qual instruções são executadas em um programa é chamada de fluxo de controle or fluxo de execução.O fluxo de controle pode variar, sempre que um programa é executado, dependendo de como o programa reage a entrada que ele recebe em time de execução.

Uma demonstrativo pode consistir em uma única linha de código que termina em um ponto-e-vírgula ou uma série de instruções de uma linha em um bloco.A demonstrativo bloco é colocado entre chaves {} e pode conter blocos aninhados.O código a seguir mostra dois exemplos de linha única demonstrativo s e uma várias linhas demonstrativo bloco:

    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 a 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 a 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 declarações

A tabela a seguir lista os diversos tipos de instruções em translation from VPE for Csharp e suas palavras-chave associadas, com links para tópicos que incluem mais informações:

Category (Categoria)

Palavras-chave translation from VPE for Csharp / anotações

Instruções de declaração

Uma demonstrativo de demonstrativo apresenta uma nova variável ou constante.Uma declaração de variável pode opcionalmente atribuir um valor à variável.Em uma declaração de constante, a atribuição é necessária.

// Variable declaration statements.


double area;


double radius = 2;




// Constant declaration statement.


const double pi = 3.14159;

Instruções de expressão

Instruções de expressão que calculam um valor necessário armazenar o valor em uma variável.

// Expression statement (assignment).


area = 3.14 * (radius * radius);




// Error. Not a statement because no assignment:


//circ * 2;




// Expression statement (method invocation).


System.Console.WriteLine();




// Expression statement (new object creation).


System.Collections.Generic.List<string> strings =


    new System.Collections.Generic.List<string>();

Instruções de seleção

Instruções de seleção permitem que você ramificar diferentes seções de código, dependendo de um ou mais condições especificadas.Para obter mais informações, consulte os seguintes tópicos:

Se, else, comutador, Caso

Instruções de iteração

Instruções de iteração permitem percorrer coleções como arrays ou executar o mesmo conjunto de instruções repetidamente até que uma condição especificada for satisfeita.Para obter mais informações, consulte os seguintes tópicos:

fazer, para, foreach, em, ao mesmo tempo

Instruções de salto

Salta declarações de controle de transferência para outra seção do código.Para obter mais informações, consulte os seguintes tópicos:

quebra, continuar, padrão, GoTo, retornar, rendimento

Instruções de tratamento de exceção

Instruções de tratamento de exceção permitem que você normalmente recuperar de condições excepcionais ocorrem em time de execução.Para obter mais informações, consulte os seguintes tópicos:

throw, try-catch, try-finally, try-catch-finally

Marcados e desmarcados

Verificados e instruções não verificadas permitem que você especifique se operações numéricas podem causar um estouro quando o resultado será armazenado em uma variável que é muito pequena para conter o valor resultante.Para obter mais informações, consulte check- and não verificado.

The fixed demonstrativo

A demonstrativo fixed impede que o coletor de lixo realocar uma variável móvel.Para obter mais informações, consulte fixo.

The lock demonstrativo

A demonstrativo bloquear permite limitar o acesso a blocos de código para apenas um thread por vez.Para obter mais informações, consulte bloquear.

Instruções rotuladas

Você pode dê um rótulo de uma demonstrativo e, em seguida, use o GoTo palavra-chave para saltar para a demonstrativo rotulada.(Consulte o exemplo na linha seguinte.)

O vazio demonstrativo

Sentença vazia consiste em um único ponto e vírgula.Ele não faz nada e pode ser usado em locais onde uma demonstrativo é necessária, mas nenhuma ação precisa ser executada.Os exemplos a seguir mostram dois usos para uma demonstrativo vazia:

void ProcessMessages()


{


    while (ProcessMessage())


        ; // Statement needed here.


}




void F()


{


    //...


    if (done) goto exit;


    //...


    exit:


    ; // Statement needed here.


}

Instruções incorporadas

Algumas instruções, incluindo fazer, ao mesmo tempo, para, and foreach, sempre ter uma demonstrativo incorporada que segue a eles.Esta demonstrativo incorporada pode ser uma única demonstrativo ou várias instruções entre chaves {} em um bloco de demonstrativo.Instruções incorporadas até mesmo uma linha podem ser delimitada por colchetes {}, sistema autônomo mostrado no exemplo a seguir:

// Recommended style. Embedded statement in a 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);

Uma demonstrativo incorporada não está entre colchetes {} não pode ser uma demonstrativo de demonstrativo ou uma demonstrativo rotulada.Isso é mostrado no exemplo a seguir:

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

Coloque a demonstrativo incorporada em um bloco para corrigir o erro:

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

Blocos de demonstrativo aninhados

demonstrativo blocos podem ser aninhados, sistema autônomo mostra o código a seguir:

foreach (string s in System.IO.Directory.GetDirectories(
    System.Environment.CurrentDirectory))
{
    if (s.StartsWith("CSharp"))
    {
        if (s.EndsWith("TempFolder"))
        {
            return s;
        }
    }

}
return "Not found.";

Instruções inacessíveis

Se o compilador determina que o fluxo de controle nunca pode alcançar um determinado demonstrativo sob qualquer circunstância, produzirá aviso CS0162, sistema autônomo mostrado no exemplo a seguir:

// An over-simplified example of unreachable code.
const int val = 5;
if (val < 4)
{
    System.Console.WriteLine("I'll never write anything."); //CS0162
}

Seções relacionadas

Especificação da linguagem C#

Para obter mais informações, consulte as seções a seguir no Especificação da linguagem C#:

  • 1.5 Instruções de

  • 8 Instruções de

Consulte também

Conceitos

Guia de Programação C#

Date

History

Motivo

Julho de 2008

Adicionados novos exemplos de código e a tabela e o texto revisado.

Aprimoramento de informações.