Operatori ed espressioni C#

  • Articolo

C# fornisce una serie di operatori. Molti di essi sono supportati datipi predefiniti e consentono di eseguire operazioni di base con i valori di tali tipi. Tali operatori includono i gruppi seguenti:

In genere, è possibile seguire l’overload di questi operatori, ovvero specificare il comportamento dell'operatore per gli operandi di un tipo definito dall'utente.

Le espressioni C# più semplici sono valori letterali (ad esempio, numeriinteri e reali) e nomi delle variabili. È possibile combinarli in espressioni complesse usando gli operatori. La precedenza e l’associatività degli operatori determinano l'ordine di esecuzione delle operazioni in un'espressione. È possibile usare le parentesi per cambiare l'ordine di valutazione imposto dalla precedenza e dall'associatività degli operatori.

Nel codice riportato di seguito, gli esempi di espressioni si trovano sul lato destro delle assegnazioni:

int a, b, c;
a = 7;
b = a;
c = b++;
b = a + b * c;
c = a >= 100 ? b : c / 10;
a = (int)Math.Sqrt(b * b + c * c);

string s = "String literal";
char l = s[s.Length - 1];

List<int> numbers = [..collection];
b = numbers.FindLast(n => n > 1);

In genere, un'espressione produce un risultato e può essere inclusa in un'altra espressione. Una chiamata a un metodo void è un esempio di espressione che non produce un risultato. Può essere usato solo come istruzione, come illustrato nell'esempio seguente:

Console.WriteLine("Hello, world!");

Ecco alcuni altri tipi di espressioni fornite da C#:

  • Espressioni di stringa interpolata che forniscono una sintassi pratica per creare stringhe formattate:

    var r = 2.3;
var message = $"The area of a circle with radius {r} is {Math.PI * r * r:F3}.";
Console.WriteLine(message);
// Output:
// The area of a circle with radius 2.3 is 16.619.

  • Espressioni lambda che consentono di creare funzioni anonime:

    int[] numbers = { 2, 3, 4, 5 };
var maximumSquare = numbers.Max(x => x * x);
Console.WriteLine(maximumSquare);
// Output:
// 25

  • Espressioni di query che consentono di usare le funzionalità di query direttamente in C#:

    int[] scores = { 90, 97, 78, 68, 85 };
IEnumerable<int> highScoresQuery =
    from score in scores
    where score > 80
    orderby score descending
    select score;
Console.WriteLine(string.Join(" ", highScoresQuery));
// Output:
// 97 90 85

È possibile usare una definizione del corpo dell'espressione per fornire una definizione concisa di un metodo, un costruttore, una proprietà, un indicizzatore o un finalizzatore.

Precedenza tra gli operatori

In un'espressione con più operatori, gli operatori con precedenza superiore vengono valutati prima degli operatori con precedenza più bassa. Nell'esempio seguente, la moltiplicazione viene eseguita per prima perché ha una precedenza più alta rispetto all'addizione:

var a = 2 + 2 * 2;
Console.WriteLine(a); //  output: 6

Usare le parentesi per cambiare l'ordine di valutazione imposto dalla precedenza tra gli operatori:

var a = (2 + 2) * 2;
Console.WriteLine(a); //  output: 8

La tabella seguente elenca gli operatori C# in ordine decrescente di precedenza. Gli operatori nella stessa riga hanno la stessa precedenza.

Operatori Categoria o nome
x.y, f(x), a[i], x?.y, x?[y], x++, x--, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x->y Primario
+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true e false Unario
x..y Intervallo
switch, con switch e with espressioni
x * y, x / y, x % y Moltiplicazione
x + y, x – y Additive
x << y, x >> y, x >>> y Shift
x < y, x > y, x <= y, x >= y, is, as Operatori relazionali e operatori di test del tipo
x == y, x != y Equality
x & y AND logico booleano o AND bit per bit
x ^ y XOR logico booleano o XOR bit per bit
x | y OR logico booleano o OR bit per bit
x && y AND condizionale
x || y OR condizionale
x ?? y Operatore null-coalescing
c? t : f Operatore condizionale
x = y, x += y, x -= y, x *= y, x /= y, x %= y, x &= y, x |= y, x ^= y, x <<= y, x >>= y, x >>>= y, x ??= y, => Assegnazione e dichiarazione lambda

Per informazioni sulla precedenza di combinatori di criteri logici, vedere la sezione Precedenza e ordine di controllo dei modelli logici dell'articolo Modelli.

Associatività degli operatori

Quando gli operatori hanno la stessa precedenza, l'associatività degli operatori determina l'ordine di esecuzione delle operazioni:

  • Gli operatori associativi a sinistra vengono valutati nell'ordine da sinistra a destra. Ad eccezione degli operatori di assegnazione e degli operatori di coalescenza di valori Null, tutti gli operatori binari sono associati a sinistra. L'espressione a + b - c viene ad esempio valutata come (a + b) - c.
  • Gli operatori associativi a destra vengono valutati nell'ordine da destra a sinistra. Gli operatori di assegnazione, gli operatori di coalescenza di valori Null, le espressioni lambda e l'operatore condizionale ?: sono associativi a destra. L'espressione x = y = z viene ad esempio valutata come x = (y = z).

Importante

In un'espressione della forma P?.A0?.A1, se P è null, non vengono valutati né A0 né A1. Analogamente, in un'espressione della forma P?.A0.A1, poiché A0 non viene valutato quando P è null, non lo è nemmeno A0.A1. Per altre informazioni, vedere le Specifiche del linguaggio C#.

Usare le parentesi per cambiare l'ordine di valutazione imposto dall'associatività degli operatori:

int a = 13 / 5 / 2;
int b = 13 / (5 / 2);
Console.WriteLine($"a = {a}, b = {b}");  // output: a = 1, b = 6

Valutazione dell'operando

Senza correlazione con la precedenza e l'associatività degli operatori, gli operandi in un'espressione vengono valutati da sinistra a destra. Gli esempi seguenti dimostrano l'ordine di valutazione degli operatori e degli operandi:

Expression Ordine di valutazione
a + b a, b, +
a + b * c a, b, c, *, +
a / b + c * d a, b, /, c, d, *, +
a / (b + c) * d a, b, c, +, /, d, *

In genere, vengono valutati tutti gli operandi dell'operatore. Tuttavia, alcuni operatori valutano gli operandi in modo condizionale. Ovvero, il valore dell'operando più a sinistra di tale operatore definisce se (o quali) altri operandi devono essere valutati. Questi operatori sono gli operatori logici condizionali AND (&&) e OR (||), gli operatori di coalescenza di valori Null ?? e ??=, gli operatori condizionali Null ?. e ?[], e l’operatore condizionale ?:. Per altre informazioni, vedere la descrizione di ogni operatore.

Specifiche del linguaggio C#

Per altre informazioni, vedere le sezioni seguenti delle specifiche del linguaggio C#:

Vedi anche