English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

C# 基础教程

C# 高级教程

C# 面向对象(OOP)

Operatore di C#

C#中的运算符是对操作数执行某些操作的一些特殊符号。在数学中，加号（+）是左右数之和。同样地，C#包括不同类型操作的各种运算符。

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：

  • 算术运算符

  • operatori di relazione

  • Logical operators

  • Operatori di bit

  • Operatori di assegnamento

  • Altri operatori

本教程将逐一讲解算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。

算术运算符

下表显示了 C# 支持的所有算术运算符。假设变量 A Il valore è 10, variabile B Il valore è 20, quindi:

OperatoreDescrizioneEsempio
+把两个操作数相加A + B 将得到 30
-从第一个操作数中减去第二个操作数A - B 将得到 -10
*把两个操作数相乘A * B 将得到 200
/分子除以分母B / A 将得到 2
%取模运算符，整除后的余数B % A 将得到 0
++自增运算符，整数值增加 1A++ 将得到 11
--自减运算符，整数值减少 1A-- 将得到 9

Esempio online

请看下面的示例，了解 C# 中所有可用的算术运算符：

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 21;
　　　　　　　　　　　　int b = 10;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a + b;
　　　　　　　　　　　　Console.WriteLine("Line 1 - c's value is {0}", c);
　　　　　　　　　　　　c = a - b;
　　　　　　　　　　　　Console.WriteLine("Linea 2 - Il valore di c è {0}", c);
　　　　　　　　　　　　c = a * b;
　　　　　　　　　　　　Console.WriteLine("Linea 3 - Il valore di c è {0}", c);
　　　　　　　　　　　　c = a / b;
　　　　　　　　　　　　Console.WriteLine("Linea 4 - Il valore di c è {0}", c);
　　　　　　　　　　　　c = a % b;
　　　　　　　　　　　　Console.WriteLine("Linea 5 - Il valore di c è {0}", c);
　　　　　　　　　　　　// ++a esegue prima l'operazione di incremento e poi assegna
　　　　　　　　　　　　c = ++a;
　　　　　　　　　　　　Console.WriteLine("Linea 6 - Il valore di c è {0}", c);
　　　　　　　　　　　　// A questo punto il valore di a è 22
　　　　　　　　　　　　// --a esegue prima l'operazione di decremento e poi assegna
　　　　　　　　　　　　c = --a;
　　　　　　　　　　　　Console.WriteLine("Linea 7 - Il valore di c è {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Linea 1 - Il valore di c è 31
Linea 2 - Il valore di c è 11
Linea 3 - Il valore di c è 210
Linea 4 - Il valore di c è 2
Linea 5 - Il valore di c è 1
Linea 6 - Il valore di c è 22
Linea 7 - Il valore di c è 21

  • c = a++: Prima assegna a c, poi esegui l'operazione di incremento su a.

  • c = ++a: Prima esegui l'operazione di incremento su a, poi assegna a c.

  • c = a--: Prima assegna a c, poi esegui l'operazione di decremento su a.

  • c = --a: Prima esegui l'operazione di decremento su a, poi assegna a c.

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 1;
　　　　　　　　　　　　int b;
　　　　　　　　　　　　// a++ assegna prima e poi esegue l'operazione di incremento
　　　　　　　　　　　　b = a++;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// ++a esegue prima l'operazione di incremento e poi assegna
　　　　　　　　　　　　a = 1; // Reinizializza a
　　　　　　　　　　　　b = ++a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// a-- assegna prima e poi esegue l'operazione di decremento
　　　　　　　　　　　　a = 1; // Reinizializza a
　　　　　　　　　　　　b = a--;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// --a esegue prima l'operazione di decremento e poi assegna
　　　　　　　　　　　　a = 1; // Reinizializza a
　　　　　　　　　　　　b = --a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Esegui il programma sopra, il risultato di output è:

a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0

operatori di relazione

La tabella seguente mostra tutti gli operatori di relazione supportati da C#. Supponiamo che la variabile A Il valore è 10, variabile B Il valore è 20, quindi:

OperatoreDescrizioneEsempio
==Controlla se i valori degli operandi sono uguali, se sì, la condizione è vera.(A == B) non è vero.
!=Controlla se i valori degli operandi sono uguali, se non lo sono, la condizione è vera.(A != B) è vero.
>Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, se sì, la condizione è vera.(A > B) non è vero.
<Controlla se il valore dell'operando sinistro è minore del valore dell'operando destro, se sì, la condizione è vera.(A < B) è vero.
>=Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, se sì, la condizione è vera.(A >= B) non è vero.
<=Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, se sì, la condizione è vera.(A <= B) is true.

Esempio online

See the following examples to understand all the available relational operators in C#:

Esempio online

using System;
class Program
{
　　static void Main(string[] args)
　　{
　　　　　　int a = 21;
　　　　　　int b = 10;
　　　　　　
　　　　　　if (a == b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line 1 - a is equal to b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line 1 - a is not equal to b");
　　　　　　}
　　　　　　if (a < b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line 2 - a is less than b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line 2 - a is not less than b");
　　　　　　}
　　　　　　if (a > b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line 3 - a is greater than b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line 3 - a is not greater than b");
　　　　　　}
　　　　　　/* Change the values of a and b */
　　　　　　a = 5;
　　　　　　b = 20;
　　　　　　if (a <= b)
　　　　　　{
　　　　　　　　　Console.WriteLine("Line 4 - a is less than or equal to b");
　　　　　　}
　　　　　　if (b >= a)
　　　　　　{
　　　　　　　　　Console.WriteLine("Line 5 - b is greater than or equal to a");
　　　　　　}
　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Line 1 - a is not equal to b
Line 2 - a is not less than b
Line 3 - a is greater than b
Line 4 - a is less than or equal to b
Line 5 - b is greater than or equal to a

Logical operators

The following table shows all the logical operators supported by C#. Assume the variable A For a boolean value true, variable B For a boolean value false, it is:

OperatoreDescrizioneEsempio
&&It is called the logical AND operator. If both operands are non-zero, the condition is true.(A && B) is false.
||It is called the logical OR operator. If any of the operands is non-zero, the condition is true.(A || B) is true.
!It is called the logical NOT operator. It is used to reverse the logical state of the operand. If the condition is true, the logical NOT operator will make it false.!(A && B) is true.

Esempio online

See the following examples to understand all the available logical operators in C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　bool a = true;
　　　　　　　　　　　　bool b = true;
　　　　　　　　　　　
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　Console.WriteLine("Line 1 - Condition is true");
　　　　　　　　　　　　}
　　　　　　　　　　　　if (a || b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line 2 - Condition is true");
　　　　　　　　　　　　}
　　　　　　　　　　　　/* Change the values of a and b */
　　　　　　　　　　　　a = false;
　　　　　　　　　　　　b = true;
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line 3 - Condition is true");
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Linea 3 - Condizione falsa");
　　　　　　　　　　　　}
　　　　　　　　　　　　if (!(a && b))
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Linea 4 - Condizione vera");
　　　　　　　　　　　　}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Linea 1 - Condizione vera
Linea 2 - Condizione vera
Linea 3 - Condizione falsa
Linea 4 - Condizione vera

Operatori di bit

Gli operatori di bit agiscono sui bit e eseguono le operazioni bit per bit. Le tabelle di verità degli operatori di bit &、| e ^ sono come segue:

pqp & qp | qp ^ q
00000
01011
11110
10011

Supponiamo che A = 60 e B = 13, rappresentati in formato binario, sono come segue:

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

La tabella seguente elenca gli operatori di bit supportati da C#. Supponiamo che la variabile A Il valore è 60, variabile B Il valore è 13, allora:

OperatoreDescrizioneEsempio
&Se esiste contemporaneamente in entrambi gli operandi, l'operatore AND binario copia un bit nel risultato.(A & B) avrà 12, ossia 0000 1100
|Se esiste in uno dei due operandi, l'operatore OR binario copia un bit nel risultato.(A | B) avrà 61, ossia 0011 1101
^Se esiste in uno dei due operandi ma non in entrambi, l'operatore di XOR binario copia un bit nel risultato.(A ^ B) avrà 49, ossia 0011 0001
~L'operatore di negazione a bit è un operatore unario, che ha l'effetto di "inverter" i bit, ovvero 0 diventa 1, 1 diventa 0, inclusi i bit di segno.(~A) avrà -61, ossia 1100 0011, che è la forma di complemento a due di un numero binario a segno.
<<L'operatore di spostamento a sinistra binario. Il valore del primo operando si sposta a sinistra di quanti bit specifica il secondo operando.A << 2 avrà 240, ossia 1111 0000
>>L'operatore di spostamento a destra binario. Il valore del primo operando si sposta a destra di quanti bit specifica il secondo operando.A >> 2 avrà 15, ossia 0000 1111

Esempio online

Vediamo l'esempio seguente per comprendere tutti gli operatori di bit disponibili in C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 60; /* 60 = 0011 1100 */　　
　　　　　　　　　　　　int b = 13; /* 13 = 0000 1101 */
　　　　　　　　　　　　int c = 0;　　　　　　　　　　　
　　　　　　　　　　　　　c = a & b; /* 12 = 0000 1100 */　
　　　　　　　　　　　　　Console.WriteLine("Linea 1 - Il valore di c è {0}", c);
　　　　　　　　　　　　　c = a | b; /* 61 = 0011 1101 */
　　　　　　　　　　　　　Console.WriteLine("Linea 2 - Il valore di c è {0}", c);
　　　　　　　　　　　　　c = a ^ b; /* 49 = 0011 0001 */
　　　　　　　　　　　　　Console.WriteLine("Linea 3 - Il valore di c è {0}", c);
　　　　　　　　　　　　　c = ~a; /* -61 = 1100 0011 */
　　　　　　　　　　　　　Console.WriteLine("Linea 4 - Il valore di c è {0}", c);
　　　　　　　　　　　　　c = a << 2; /* 240 = 1111 0000 */
　　　　　　　　　　　　　Console.WriteLine("Linea 5 - Il valore di c è {0}", c);
　　　　　　　　　　　　　c = a >> 2; /* 15 = 0000 1111 */
　　　　　　　　　　　　　Console.WriteLine("Linea 6 - Il valore di c è {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Linea 1 - Il valore di c è 12
Linea 2 - Il valore di c è 61
Linea 3 - Il valore di c è 49
Linea 4 - Il valore di c è -61
Linea 5 - Il valore di c è 240
Linea 6 - Il valore di c è 15

Operatori di assegnamento

La tabella sottostante elenca gli operatori di assegnamento supportati da C#:

OperatoreDescrizioneEsempio
=L'operatore di assegnamento semplice, assegna il valore del numero di destra al numero di sinistraC = A + B assegnerà il valore di A + B a C
+=L'operatore di assegnamento di somma, assegna il risultato della somma del numero di destra sul numero di sinistra al numero di sinistraC += A è equivalente a C = C + A
-=L'operatore di assegnamento di sottrazione, assegna il risultato della sottrazione del numero di destra dal numero di sinistra al numero di sinistraC -= A è equivalente a C = C - A
*=L'operatore di assegnamento di moltiplicazione, assegna il risultato della moltiplicazione del numero di destra sul numero di sinistra al numero di sinistraC *= A è equivalente a C = C * A
/=L'operatore di assegnamento di divisione, assegna il risultato della divisione del numero di destra sul numero di sinistra al numero di sinistraC /= A è equivalente a C = C / A
%=Operatore di modulo e assegnamento, assegna il modulo dei due operandi al primo operandoC %= A è equivalente a C = C % A
<<=Operatore di shift a sinistra e assegnamentoC <<= 2 è equivalente a C = C << 2
>>=Operatore di shift a destra e assegnamentoC >>= 2 è equivalente a C = C >> 2
&=Operatore di bitwise AND e assegnamentoC &= 2 è equivalente a C = C & 2
^=Operatore di bitwise XOR e assegnamentoC ^= 2 è equivalente a C = C ^ 2
|=Operatore di bitwise OR e assegnamentoC |= 2 è equivalente a C = C | 2

Esempio online

Ecco un esempio per comprendere tutti gli operatori di assegnamento disponibili in C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 21;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a;
　　　　　　　　　　　　Console.WriteLine("Line 1 - = il valore di c = {0}", c);
　　　　　　　　　　　　c += a;
　　　　　　　　　　　　Console.WriteLine("Line 2 - += il valore di c = {0}", c);
　　　　　　　　　　　　c -= a;
　　　　　　　　　　　　Console.WriteLine("Line 3 - -= il valore di c = {0}", c);
　　　　　　　　　　　　c *= a;
　　　　　　　　　　　　Console.WriteLine("Line 4 - *= il valore di c = {0}", c);
　　　　　　　　　　　　c /= a;
　　　　　　　　　　　　Console.WriteLine("Line 5 - /= il valore di c = {0}", c);
　　　　　　　　　　　　c = 200;
　　　　　　　　　　　　c %= a;
　　　　　　　　　　　　Console.WriteLine("Line 6 - %= il valore di c = {0}", c);
　　　　　　　　　　　　c <<= 2;
　　　　　　　　　　　　Console.WriteLine("Line 7 - <<= il valore di c = {0}", c);
　　　　　　　　　　　　c >>= 2;
　　　　　　　　　　　　Console.WriteLine("Line 8 - >>= il valore di c = {0}", c);
　　　　　　　　　　　　c &= 2;
　　　　　　　　　　　　Console.WriteLine("Line 9 - &= il valore di c = {0}", c);
　　　　　　　　　　　　c ^= 2;
　　　　　　　　　　　　Console.WriteLine("Line 10 - ^= il valore di c = {0}", c);
　　　　　　　　　　　　c |= 2;
　　　　　　　　　　　　Console.WriteLine("Line 11 - |= il valore di c = {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Line 1 - = il valore di c = 21
Line 2 - += il valore di c = 42
Linea 2 - -= La valore di c è 21
Linea 3 - *= La valore di c è 441
Linea 4 - /= La valore di c è 21
Linea 5 - %= La valore di c è 11
Linea 6 - <<= La valore di c è 44
Linea 7 - >>= La valore di c è 11
Linea 9 - &= La valore di c è 2
Linea 10 - ^= La valore di c è 0
Linea 11 - |= La valore di c è 2

Altri operatori

La tabella sottostante elenca altri importanti operatori supportati da C#, inclusi sizeof、typeof E ? :.

OperatoreDescrizioneEsempio
sizeof();Restituisce la dimensione del tipo di dati.sizeof(int) restituirà 4.
typeof();Restituisce il tipo della classe.typeof(StreamReader);
&Restituisce l'indirizzo della variabile.&a; ottiene l'indirizzo reale della variabile.
*Pointer di variabile.*a; pointing to a variable.
? :Espressione condizionaleSe la condizione è vera ? allora X : altrimenti Y
isDetermina se un oggetto è di un tipo specifico.If( Ford is Car) // Verifica se Ford è un oggetto della classe Car.
asForza il casting, anche se il casting fallisce non viene lanciata un'eccezione.Object obj = new StringReader("Hello");
　 　StringReader r = obj as StringReader;

Esempio online

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　/* Esempio di operatore sizeof */
　　　　　　　　　Console.WriteLine("La dimensione di int è {0}", sizeof(int));
　　　　　　　　　Console.WriteLine("La dimensione di short è {0}", sizeof(short));
　　　　　　　　　Console.WriteLine("La dimensione di double è {0}", sizeof(double));
　　　　　　　　　
　　　　　　　　　/* Esempio di operatore ternario */
　　　　　　　　　int a, b;
　　　　　　　　　a = 10;
　　　　　　　　　b = (a == 1) ? 20 : 30;
　　　　　　　　　Console.WriteLine("Il valore di b è {0}", b);
　　　　　　　　　b = (a == 10) ? 20 : 30;
　　　　　　　　　Console.WriteLine("Il valore di b è {0}", b);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

La dimensione di int è 4
La dimensione di short è 2
La dimensione di double è 8
Il valore di b è 30
Il valore di b è 20

Priorità degli operatori in C#

La priorità degli operatori determina la combinazione degli elementi nell'espressione. Questo influisce su come viene calcolata un'espressione. Alcuni operatori hanno una priorità più alta rispetto ad altri, ad esempio gli operatori di moltiplicazione e divisione hanno una priorità più alta rispetto agli operatori di addizione e sottrazione.

Ad esempio x = 7 + 3 * 2, qui x viene assegnato il valore 13, non 20, perché l'operatore * ha una priorità più alta rispetto a +, quindi viene calcolata prima la moltiplicazione 3*2, poi aggiunta 7.

La seguente tabella elenca tutti gli operatori per priorità operativa, con gli operatori di priorità più alta in alto nella tabella e quelli di priorità più bassa in basso. Negli espressioni, gli operatori di priorità più alta vengono calcolati per primi.

Categoria　Operatore　Associatività　
Suffisso　( ) [] -> . ++ -- 　Da sinistra a destra　
Unario　+ - ! ~ ++ -- (type)* & sizeof　Da destra a sinistra　
Moltiplicazione Divisione　* / %　Da sinistra a destra　
Addizione Sottrazione　+ -　Da sinistra a destra　
Spostamento　<< >>　Da sinistra a destra　
Relazionale　< <= > >=　Da sinistra a destra　
Uguaglianza　== !=　Da sinistra a destra　
Bitwise E AND　&　Da sinistra a destra　
Bitwise ESR XOR　^　Da sinistra a destra　
Bitwise O OR　|　Da sinistra a destra　
Logico E AND　&&　Da sinistra a destra　
Logico O OR　||　Da sinistra a destra　
Condizionale　?:　Da destra a sinistra　
Assegnazione　= += -= *= /= %= >>= <<= &= ^= |=　Da destra a sinistra　
Virgola　,　Da sinistra a destra　

Esempio online

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　int a = 20;
　　　　　　　　　int b = 10;
　　　　　　　　　int c = 15;
　　　　　　　　　int d = 5;
　　　　　　　　　int e;
　　　　　　　　　e = (a + b) * c / d; // ( 30 * 15 ) / 5
　　　　　　　　　Console.WriteLine("(a + b) * c / d il valore è {0}", e);
　　　　　　　　　e = ((a + b) * c) / d; // (30 * 15) / 5
　　　　　　　　　Console.WriteLine("((a + b) * c) / d il valore è {0}", e);
　　　　　　　　　e = (a + b) * (c / d); // (30) * (15/5)
　　　　　　　　　Console.WriteLine("(a + b) * (c / d) il valore è {0}", e);
　　　　　　　　　e = a + (b * c) / d; // 20 + (150/5)
　　　　　　　　　e = a + (b * c) / d; // 20 + (150/5)
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Il valore di (a + b) * c / d è 90
Il valore di ((a + b) * c) / d è 90
Il valore di (a + b) * (c / d) è 90
Il valore di a + (b * c) / d è 50
FileInfo di C#Interfaccia di C# (Interface)