Instrucțiuni C#

Tradus din această pagină oficială de documentație Microsoft.

Acțiunile unui program sunt exprimate folosind instrucțiuni (en. statements). C# suportă câteva feluri diferite de instrucțiuni, o parte din ele sunt definite în termeni de instrucțiuni incorporate.

Un bloc permite multiple instrucțiuni să fie scrise în contexte unde o singură instrucțiune este permisă. Un bloc consistă într-o listă de instrucțiuni scrise între delimitatorii { și }.

Instrucțiunile de declarare sunt folosite pentru a declara variabile și constante locale.

Instrucțiunile expresie sunt folosite pentru a evalua expresii. Expresiile care pot fi folosite ca instrucțiuni includ invocarea metodelor, alocarea obiectelor folosind operatorul new, atribuirea folosind = și operatorii de atribuire compusă, operații de incrementare și decrementare folosind operatorii ++ și -- și expresiile await.

Instrucțiunile de selecție sunt folosite pentru a selecta una dintre mai multe instrucțiuni posibile pentru execuție bazat pe valoarea unei expresii. In acest grup sunt instrucțiunile if și switch.

Instrucțiunile de iterare sunt folosite să execute în mod repetat o instrucțiune incorporată. In acest grup sunt instrucțiunile while, do, for, și foreach.

Instrucțiunile de salt sunt folosite pentru a transfera controlul. In acest grup sunt instrucțiunile: break, continue, goto, throw, return, și yield.

Instrucțiunea try...catch este folosită pentru a prinde excepțiile care au loc în timpul execuției unui bloc, și instrucțiunea try...finally este folosită pentru a specifica un cod de finalizare care este executat întotdeauna, fie că o excepție a avut loc, fie că nu.

Instrucțiunile checked și unchecked sunt folosite pentru a controla contextul de verificare de depășire pentru operații aritmetice și conversii de tip întreg.

Instrucțiunea lock este folosită pentru a obține blocarea (en. lock) de excludere mutuală pentru un obiect dat, a executa o instrucțiune, și apoi a elibera blocarea.

Instrucțiunea using este folosită pentru a obține o resursă, a executa o instrucțiune, și apoi a elimina acea resursă.

In cele ce urmează se listează felurile de instrucțiuni care pot fi folosite, și se oferă un exemplu pentru fiecare.

• Declarare de variabilă locală:

static void Declaratii(string[] args)
{
    int a;
    int b = 2, c = 3;
    a = 1;
    Console.WriteLine(a + b + c);
}

• Declarare de constantă locală:

static void DeclaratiiConstante(string[] args)
{
    const float pi = 3.1415927f;
    const int r = 25;
    Console.WriteLine(pi * r * r);
}

• Instrucțiune expresie:

static void Expresii(string[] args)
{
    int i;
    i = 123;                // Instructiune expresie
    Console.WriteLine(i);   // Instructiune expresie
    i++;                    // Instructiune expresie
    Console.WriteLine(i);   // Instructiune expresie
}

• Instrucțiune if:

static void InstructiuneIf(string[] args)
{
    if (args.Length == 0)
    {
        Console.WriteLine("Nici un argument");
    }
    else
    {
        Console.WriteLine("Unul sau mai multe argumente");
    }
}

• Instrucțiune switch:

static void InstructiuneSwitch(string[] args)
{
    int n = args.Length;
    switch (n)
    {
        case 0:
            Console.WriteLine("Nici un argument");
            break;
        case 1:
            Console.WriteLine("Un argument");
            break;
        default:
            Console.WriteLine($"{n} argumente");
            break;
    }
}

• Instrucțiune while:

static void InstructiuneWhile(string[] args)
{
    int i = 0;
    while (i < args.Length)
    {
        Console.WriteLine(args[i]);
        i++;
    }
}

• Instrucțiune do:

static void InstructiuneDo(string[] args)
{
    string s;
    do
    {
        s = Console.ReadLine();
        Console.WriteLine(s);
    } while (!string.IsNullOrEmpty(s));
}

• Instrucțiune for:

static void InstructiuneFor(string[] args)
{
    for (int i = 0; i < args.Length; i++)
    {
        Console.WriteLine(args[i]);
    }
}

• Instrucțiune foreach:

static void InstructiuneForeach(string[] args)
{
    foreach (string s in args)
    {
        Console.WriteLine(s);
    }
}

• Instrucțiune break:

static void InstructiuneBreak(string[] args)
{
    while (true)
    {
        string s = Console.ReadLine();
        if (string.IsNullOrEmpty(s))
            break;
        Console.WriteLine(s);
    }
}

• Instrucțiune continue:

static void InstructiuneContinue(string[] args)
{
    for (int i = 0; i < args.Length; i++)
    {
        if (args[i].StartsWith("/"))
            continue;
        Console.WriteLine(args[i]);
    }
}

• Instrucțiune goto:

static void InstructiuneGoTo(string[] args)
{
    int i = 0;
    goto verificare;
    repetare:
    Console.WriteLine(args[i++]);
    verificare:
    if (i < args.Length)
        goto repetare;
}

• Instrucțiune return:

static int Aduna(int a, int b)
{
    return a + b;
}
static void InstructiuneReturn(string[] args)
{
   Console.WriteLine(Aduna(1, 2));
   return;
}

• Instrucțiune yield:

static System.Collections.Generic.IEnumerable<int> Interval(int deLa, int panaLa)
{
    for (int i = deLa; i < panaLa; i++)
    {
        yield return i;
    }
    yield break;
}
static void InstructiuneYield(string[] args)
{
    foreach (int i in Interval(-10,10))
    {
        Console.WriteLine(i);
    }
}

• Instrucțiuni throw și try:

static double Imparte(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("Doua numere necesare");
        }
        double x = double.Parse(args[0]);
        double y = double.Parse(args[1]);
        Console.WriteLine(Imparte(x, y));
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.Message);
    }
    finally
    {
        Console.WriteLine("La revedere!");
    }
}

• Instrucțiuni checked și unchecked:

static void CheckedUnchecked(string[] args)
{
    int x = int.MaxValue;
    unchecked
    {
        Console.WriteLine(x + 1);  // Depasire
    }
    checked
    {
        Console.WriteLine(x + 1);  // Exceptie
    }    
}

• Instrucțiune lock:

class Cont
{
    decimal sold;
    private readonly object sync = new object();
    public void Extragere(decimal suma)
    {
        lock (sync)
        {
            if (suma > sold)
            {
                throw new Exception(
                    "Fonduri insuficiente");
            }
            sold -= suma;
        }
    }
}

• Instrucțiune using:

static void InstructiuneUsing(string[] args)
{
    using (TextWriter w = File.CreateText("test.txt"))
    {
        w.WriteLine("Rândul unu");
        w.WriteLine("Rândul doi");
        w.WriteLine("Rândul trei");
    }
}

Tradus din această pagină oficială de documentație Microsoft.