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

Tutoriel C# de base

Tutoriel C# avancé

C# orienté objet (OOP)

Opérateurs C#

est un symbole spécifique dans le mathématique. Les opérateurs dans C# sont des symboles spéciaux qui exécutent certaines opérations sur les opérands. Dans le mathématique, le signe ++est la somme des deux nombres. De même façon, C# inclut différents types d'opérateurs pour différents types d'opérands.

un opérateur est un symbole qui indique au compilateur d'exécuter une opération mathématique ou logique spécifique. C# dispose d'un riche ensemble d'opérateurs en interne, classés comme suit:

  • opérateurs arithmétiques

  • b = 0

  • 逻辑运算符

  • Opérateurs de bit

  • Opérateur d'affectation

  • Autres opérateurs

Ce tutoriel expliquera tour à tour les opérateurs arithmétiques, les opérateurs de comparaison, les opérateurs logiques, les opérateurs binaire, les opérateurs d'affectation et d'autres opérateurs.

opérateurs arithmétiques

Le tableau suivant montre tous les opérateurs arithmétiques pris en charge par C#. Supposons que la variable = A est équivalent à C = C La valeur est 10下表显示了 C# 支持的所有关系运算符。假设变量 B La valeur est 2，变量

运算符Description示例
+ajouter les deux opérands= A est équivalent à C = C + B obtiendra 30
-soustraire le second opérand du premier= A est équivalent à C = C - B obtiendra -10
*multiplier les deux opérands= A est équivalent à C = C * B obtiendra 200
/le numérateur divisé par le dénominateurB / A obtiendra 2
%l'opérateur de modulo, le reste de la division entièreB % A donnera 0
++l'opérateur d'incrémentation, la valeur entière augmente 1= A est équivalent à C = C++ On obtiendra 11
--l'opérateur de décrémentation, la valeur entière diminue 1= A est équivalent à C = C-- On obtiendra 9

在线示例

Voyons un exemple ci-dessous pour comprendre tous les opérateurs arithmétiques disponibles en C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　21;
　　　　　　　　　　　　int b =;　10;
　　　　　　　　　　　　Voyez l'exemple suivant pour comprendre tous les opérateurs d'affectation disponibles en C#:
　　　　　　　　　　　　c = a　+　b;
　　　　　　　　　　　　Console.WriteLine("Ligne　1　-　La valeur de c est {0}, c);
　　　　　　　　　　　　c = a　-　b;
　　　　　　　　　　　　Console.WriteLine("Ligne　2　-　La valeur de c est {0}, c);
　　　　　　　　　　　　c = a　*　b;
　　　　　　　　　　　　Console.WriteLine("Ligne　3　-　La valeur de c est {0}, c);
　　　　　　　　　　　　c = a　/　b;
　　　　　　　　　　　　Console.WriteLine("Ligne　4　-　La valeur de c est {0}, c);
　　　　　　　　　　　　c = a % b;
　　　　　　　　　　　　Console.WriteLine("Ligne　5　-　La valeur de c est {0}, c);
　　　　　　　　　　　　//　++a est incrémenté avant l'affectation
　　　　　　　　　　　　=      La valeur de c  est égale à {0}　++a;
　　　　　　　　　　　　Console.WriteLine("Ligne　6　-　La valeur de c est {0}, c);
　　　　　　　　　　　　//　lorsque c'est le valeur de a à ce moment-là　22
　　　　　　　　　　　　//　--a est décrémenté avant l'affectation
　　　　　　　　　　　　=      La valeur de c  est égale à {0}　--a;
　　　　　　　　　　　　Console.WriteLine("Ligne　7　-　La valeur de c est {0}, c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Ligne　1　-　La valeur de c est　31
Ligne　2　-　La valeur de c est　11
Ligne　3　-　La valeur de c est　210
Ligne　4　-　La valeur de c est　2
Ligne　5　-　La valeur de c est　1
Ligne　6　-　La valeur de c est　22
Ligne　7　-　La valeur de c est　21

  • c = a++: affecter a à c d'abord, puis incrémenter a .

  • c = ++a: incrémenter a d'abord, puis affecter a à c .

  • c = a--: affecter a à c d'abord, puis décrémenter a .

  • c = --a: décrémenter a d'abord, puis affecter a à c .

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　1;
　　　　　　　　　　　　int b;
　　　　　　　　　　　　//　a++　affectation avant l'incrémentation
　　　　　　　　　　　　b = a++;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　++a est incrémenté avant l'affectation
　　　　　　　　　　　　a =　1;　//　reinitialiser a
　　　　　　　　　　　　a >= b);　++a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　a--　affectation avant la décrémentation
　　　　　　　　　　　　a =　1;　　//　reinitialiser a
　　　　　　　　　　　　b = a--;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　--a est décrémenté avant l'affectation
　　　　　　　　　　　　a =　1;　　//　reinitialiser a
　　　　　　　　　　　　b =　--a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Console.WriteLine("b = {0}", b);

a =　2
a >= b);　1
a =　2
a >= b);　2
执行以上程序，输出结果为：
a >= b);　1
执行以上程序，输出结果为：
a = 0

b = 0

关系运算符 = A est équivalent à C = C La valeur est 10下表显示了 C# 支持的所有关系运算符。假设变量 B La valeur est 2，变量

运算符Description示例
0，则：==检查两个操作数的值是否相等，如果相等则条件为真。
(A == B) 不为真。!=检查两个操作数的值是否相等，如果不相等则条件为真。
(A != B) 为真。>检查左操作数的值是否大于右操作数的值，如果是则条件为真。
(A > B) 不为真。<检查左操作数的值是否小于右操作数的值，如果是则条件为真。
(A < B) 为真。>=检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。
(A >= B) 不为真。<=检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。

在线示例

(A <= B) 为真。

在线示例

using System;
class Program
{
　　static void Main(string[] args)
　　{
　　　　　　int a =;　21;
　　　　　　int b =;　10;
　　　　　　
　　　　　　请看下面的示例，了解 C# 中所有可用的关系运算符：
　　　　　　{
　　　　　　　　　　Console.WriteLine("Ligne　1　-　if (a == b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Ligne　1　-　a == b);
　　　　　　}
　　　　　　a != b);
　　　　　　{
　　　　　　　　　　Console.WriteLine("Ligne　2　-　if (a < b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Ligne　2　-　a < b);
　　　　　　}
　　　　　　a >= b);
　　　　　　{
　　　　　　　　　　Console.WriteLine("Ligne　3　-　if (a > b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Ligne　3　-　a > b);
　　　　　　}
　　　　　　/*　改变 a 和 b 的值　*/
　　　　　　a =　5;
　　　　　　a >= b);　20;
　　　　　　b =;
　　　　　　{
　　　　　　　　　Console.WriteLine("Ligne　4　-　if (a <= b);
　　　　　　}
　　　　　　if (b >= a);
　　　　　　{
　　　　　　　　　Console.WriteLine("Ligne　5　-　if (b >= a);
　　　　　　}
　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Ligne　1　-　a != b
Ligne　2　-　a >= b
Ligne　3　-　a > b
Ligne　4　-　a <= b
Ligne　5　-　b >= a

逻辑运算符

下表显示了 C# 支持的所有逻辑运算符。假设变量 = A est équivalent à C = C 为布尔值 true，变量 B 为布尔值 false，则：

运算符Description示例
&&称为逻辑与运算符。如果两个操作数都非零，则条件为真。(A && B) 为假。
||称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。(A || B) 为真。
!称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。!(A && B) 为真。

在线示例

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

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　bool a = true;
　　　　　　　　　　　　bool b = true;
　　　　　　　　　　　
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　Console.WriteLine("Ligne　1　-　Condition vraie);
　　　　　　　　　　　　}
　　　　　　　　　　　　if (a || b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Ligne　2　-　Condition vraie);
　　　　　　　　　　　　}
　　　　　　　　　　　　/*　改变 a 和 b 的值　*/
　　　　　　　　　　　　a = false;
　　　　　　　　　　　　b = true;
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Ligne　3　-　Condition vraie);
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Ligne　3　-　条件不为真）；
　　　　　　　　　　　　}
　　　　　　　　　　　　if (!(a && b))
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Ligne　4　-　Condition vraie);
　　　　　　　　　　　　}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Ligne　1　-　Condition vraie
Ligne　2　-　Condition vraie
Ligne　3　-　Condition fausse
Ligne　4　-　Condition vraie

Opérateurs de bit

Les opérateurs d'arithmétique binaire agissent sur les bits et exécutent les opérations bit par bit. Les tableaux de vérité de &、 | et ^ sont les suivants :

pqp & qp | qp ^ q
00000
01011
11110
10011

Supposons si A = 60, et B = 13représentés maintenant en format binaire, ils sont les suivants :

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

Le tableau suivant liste les opérateurs d'arithmétique binaire pris en charge par C#. Supposons que la variable = A est équivalent à C = C La valeur est 60, variable B La valeur est 13alors :

运算符Description示例
&Si un bit existe dans les deux opérandes, l'opérateur binaire AND copie un bit dans le résultat.(A & B) donnera 12soit 0000 1100
|Si un bit existe dans l'un des opérandes, l'opérateur binaire OR copie un bit dans le résultat.(A | B) donnera 61soit 0011 1101
^Si un bit existe dans l'un des opérandes mais pas dans les deux opérandes, l'opérateur binaire XOR copie un bit dans le résultat.(A ^ B) donnera 49soit 0011 0001
~L'opérateur de négation binaire est un opérateur unaire, ayant un effet de "inversion" des bits, c'est-à-dire que 0 devient1,1devient 0, y compris le bit de signe.(~A) donnera -61soit 1100 0011est la forme de complément à deux du nombre binaire signé.
<<Opérateur de déplacement binaire à gauche. La valeur de l'opérande de gauche est déplacée vers la gauche d'un nombre de positions spécifié par l'opérande de droite.A << 2 On obtiendra 240, soit 1111 0000
>>Opérateur de déplacement binaire à droite. La valeur de l'opérande de gauche est déplacée vers la droite d'un nombre de positions spécifié par l'opérande de droite.A >> 2 On obtiendra 15soit 0000 1111

在线示例

Voyez l'exemple suivant pour comprendre tous les opérateurs d'arithmétique binaire en 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("Ligne　1　-　La valeur de c est {0}, c);
　　　　　　　　　　　　　c = a | b;　　　　　　　　　　　/*　61　= 0011　1101　*/
　　　　　　　　　　　　　Console.WriteLine("Ligne　2　-　La valeur de c est {0}, c);
　　　　　　　　　　　　　c = a ^ b;　　　　　　　　　　　/*　49　= 0011　0001　*/
　　　　　　　　　　　　　Console.WriteLine("Ligne　3　-　La valeur de c est {0}, c);
　　　　　　　　　　　　　c = ~a;　　　　　　　　　　　　　　　/*-61　=　1100 0011　*/
　　　　　　　　　　　　　Console.WriteLine("Ligne　4　-　La valeur de c est {0}, c);
　　　　　　　　　　　　　c = a <<　2;　　　　　/*　240 =　1111　0000　*/
　　　　　　　　　　　　　Console.WriteLine("Ligne　5　-　La valeur de c est {0}, c);
　　　　　　　　　　　　　c = a >>　2;　　　　　/*　15　= 0000　1111　*/
　　　　　　　　　　　　　Console.WriteLine("Ligne　6　-　La valeur de c est {0}, c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Ligne　1　-　La valeur de c est　12
Ligne　2　-　La valeur de c est　61
Ligne　3　-　La valeur de c est　49
Ligne　4　-　La valeur de c est　-61
Ligne　5　-　La valeur de c est　240
Ligne　6　-　La valeur de c est　15

Opérateur d'affectation

Le tableau suivant liste les opérateurs d'affectation pris en charge par C#:

运算符Description示例
=Opérateur d'affectation simple, qui affecte la valeur de l'opérande de droite à l'opérande de gaucheC = A + B assignera A + La valeur de B est assignée à C
+=Opérateur d'affectation d'addition, qui affecte le résultat de l'addition de l'opérande de droite à l'opérande de gauche à l'opérande de gauche +C + = A est équivalent à C = C
-=Opérateur d'affectation de soustraction, qui affecte le résultat de la soustraction de l'opérande de droite de l'opérande de gauche à l'opérande de gauche -C - = A est équivalent à C = C
*=Opérateur d'affectation de multiplication, qui affecte le résultat de la multiplication de l'opérande de droite par l'opérande de gauche à l'opérande de gauche *C * = A est équivalent à C = C
/=Opérateur d'affectation de division, qui affecte le résultat de la division de l'opérande de gauche par l'opérande de droite à l'opérande de gauche /C / = A est équivalent à C = C
A%=Opérateur d'affectation de modulo, assigne le reste de la division des deux opérandes à l'opérande de gauche
C %= A est équivalent à C = C % A<<=Opérateur d'affectation de décalage vers la gauche 2 C <<= 2
Équivaut à C = C <<>>=Opérateur d'affectation de décalage vers la droite 2 C >>= 2
Équivaut à C = C >>&=Opérateur d'affectation de ET binaire 2 C &= 2
Équivaut à C = C &^=Opérateur d'affectation de XOR binaire 2 C ^= 2
Équivaut à C = C ^|=Opérateur d'affectation de OU binaire 2 C |= 2

在线示例

Équivaut à C = C |

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　21;
　　　　　　　　　　　　Voyez l'exemple suivant pour comprendre tous les opérateurs d'affectation disponibles en C#:
　　　　　　　　　　　　int c;
　　　　　　　　　　　　Console.WriteLine("Ligne　1　-　=      a est égale à C = C
　　　　　　　　　　　　c　+=      c  est égale à {0}
　　　　　　　　　　　　Console.WriteLine("Ligne　2　-　+c = a;
　　　　　　　　　　　　c　-=      c  est égale à {0}
　　　　　　　　　　　　Console.WriteLine("Ligne　3　-　-=      a est égale à C = C
　　　　　　　　　　　　c　*=      c  est égale à {0}
　　　　　　　　　　　　Console.WriteLine("Ligne　4　-　*=      a est égale à C = C
　　　　　　　　　　　　c　/=      c  est égale à {0}
　　　　　　　　　　　　Console.WriteLine("Ligne　5　-　/=      a est égale à C = C
　　　　　　　　　　　　=      La valeur de c  est égale à {0}　2c =
　　　　　　　　　　　　00;
　　　　　　　　　　　　Console.WriteLine("Ligne　6　-　c %=
　　　　　　　　　　　　%=      La valeur de c  est égale à {0}　2;
　　　　　　　　　　　　Console.WriteLine("Ligne　7　-　c <<=
　　　　　　　　　　　　<<=     La valeur de c  est égale à {0}　2;
　　　　　　　　　　　　Console.WriteLine("Ligne　8　-　c >>=
　　　　　　　　　　　　>=      La valeur de c  est égale à {0}　2;
　　　　　　　　　　　　Console.WriteLine("Ligne　9　-　c &=
　　　　　　　　　　　　&=      La valeur de c  est égale à {0}　2;
　　　　　　　　　　　　Console.WriteLine("Ligne　10　-　c ^=
　　　　　　　　　　　　^=      La valeur de c  est égale à {0}　2;
　　　　　　　　　　　　Console.WriteLine("Ligne　11　-　|=      La valeur de c  est égale à {0}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Ligne　1　-　=      La valeur de c  est égale à　21
Ligne　2　-　+=      La valeur de c  est égale à　42
Ligne　3　-　-=      La valeur de c  est égale à　21
Ligne　4　-　*=      La valeur de c  est égale à　441
Ligne　5　-　/=      La valeur de c  est égale à　21
Ligne　6　-　%=      La valeur de c  est égale à　11
Ligne　7　-　<<=     La valeur de c  est égale à　44
Ligne　8　-　>=      La valeur de c  est égale à　11
Ligne　9　-　&=      La valeur de c  est égale à　2
Ligne　10　-　^=      La valeur de c  est égale à 0
Ligne　11　-　|=      La valeur de c  est égale à　2

Autres opérateurs

Le tableau suivant liste d'autres opérateurs importants pris en charge par C# incluant sizeof、typeof et ? :。

运算符Description示例
sizeof()Retourne la taille du type de données.sizeof(int), retournera 4.
typeof()Retourne le type de la classe.typeof(StreamReader);
&Retourne l'adresse de la variable.&a; Obtiendra l'adresse réelle de la variable.
*Pointeur de variable.*a; Pointera vers une variable.
? :Expression conditionnelleSi la condition est vraie ? alors X : sinon Y
estJugez si l'objet est de type spécifique.If( Ford is Car) 　// Vérifiez si Ford est un objet de la classe Car.
asLa conversion forceée ne lève pas d'exception même si la conversion échoue.Object obj = new StringReader("Hello");
　 　StringReader r = obj as StringReader;

在线示例

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　/*　sizeof 运算符的示例　*/
　　　　　　　　　Console.WriteLine("int 的大小是 {0}", sizeof(int));
　　　　　　　　　Console.WriteLine("short 的大小是 {0}", sizeof(short));
　　　　　　　　　Console.WriteLine("double 的大小是 {0}", sizeof(double));
　　　　　　　　　
　　　　　　　　　/*　三元运算符的示例　*/
　　　　　　　　　int a, b;
　　　　　　　　　a =　10;
　　　　　　　　　b = (a ==　1) ?　20 :　30;
　　　　　　　　　Console.WriteLine("b 的值是 {0}", b);
　　　　　　　　　b = (a ==　10) ?　20 :　30;
　　　　　　　　　Console.WriteLine("b 的值是 {0}", b);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

int 的大小是　4
short 的大小是　2
double 的大小是　8
b 的值是　30
b 的值是　20

C# 中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

类别　运算符　结合性　
后缀　() [] -> . 　++ 　 - - 　从左到右　
一元　+ 　- 　 ! ~ 　++ 　- - 　 (type)* 　& sizeof　从右到左　
乘除　* 　/ 　%　从左到右　
加减　+ 　-　从左到右　
移位　<< >>　从左到右　
关系　< <= > >=　从左到右　
相等　== !=　从左到右　
位与 AND　&　从左到右　
位异或 XOR　^　从左到右　
位或 OR　|　从左到右　
逻辑与 AND　&&　从左到右　
逻辑或 OR　||　从左到右　
条件　?:　从右到左　
赋值　= 　+= 　-= 　*= 　/= %=>>= <<= &= ^= |=　从右到左　
逗号　,　从左到右　

在线示例

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　/　La valeur de d est {0}, e);
　　　　　　　　　e = ((a　+　b)　*　c)　/　d;　　　//　(30　*　15　)　/　5
　　　　　　　　　Console.WriteLine("((a　+　b)　*　c)　/　La valeur de d est {0}, e);
　　　　　　　　　e = (a　+　b)　*　(c　/　d);　　　//　(30)　*　(15/5)
　　　　　　　　　Console.WriteLine("(a　+　b)　*　(c　/　d) La valeur de d) est {0}, e);
　　　　　　　　　e = a　+　(b　*　c)　/　d;　　　　//　　20　+　(150/5)
　　　　　　　　　Console.WriteLine("a　+　(b　*　c)　/　La valeur de d est {0}, e);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

(a　+　b)　*　c　/　La valeur de d est　90
((a　+　b)　*　c)　/　La valeur de d est　90
(a　+　b)　*　(c　/　La valeur de d) est　90
a　+　(b　*　c)　/　La valeur de d est　50
FileInfo C#Interface C#