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

C#基础教程

C#高级教程

C#面向对象(OOP)

C#-Operatoren

in der Mathematik ist das Pluszeichen (+) der Operator für die Addition. Ebenso enthält C# verschiedene Operatoren für verschiedene Operationen.+ist die Summe der linken und rechten Werte. Ebenso umfasst C# verschiedene Arten von Operatoren für verschiedene Operationen.

Ein Operator ist ein Symbol, das dem Compiler mitteilt, eine spezifische mathematische oder logische Operation auszuführen. C# hat eine reiche Sammlung eingebauter Operatoren, die wie folgt kategorisiert werden können:

  • Arithmetischer Operator

  • Verhoudingsoperator

  • Logischer Operator

  • Bit-Operator

  • Zuweisungsoperator

  • 其他运算符

Diese Anleitung wird die arithmetischen, relationalen, logischen, bitweisen, Zuweisungs- und anderen Operatoren nacheinander erläutern.

Arithmetischer Operator

Die nachstehende Tabelle zeigt alle arithmetischen Operatoren, die von C# unterstützt werden. Angenommen, die Variable A Der Wert ist 10, Variable B Der Wert ist 20, dann:

运算符描述示例
+Addieren Sie die beiden OperandenA + B erhält 30
-Subtrahieren Sie den zweiten Operanden vom erstenA - B erhält -10
*Multiplizieren Sie die beiden OperandenA * B erhält 200
/Nenner durch Zähler geteiltB / A erhält 2
%Modulo-Operator, Rest der ganzzahligen DivisionB % A ergibt 0
++Erhöhen Sie den Wert des Ganzen 1A++ wird erhalten 11
--Verringern Sie den Wert des Ganzen 1A-- wird erhalten 9

在线示例

Sehen Sie sich das folgende Beispiel an, um alle verfügbaren arithmetischen Operatoren in C# zu verstehen:

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　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　c = a　-　b;
　　　　　　　　　　　　Console.WriteLine("Line　2　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　c = a　*　b;
　　　　　　　　　　　　Console.WriteLine("Line　3　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　c = a　/　b;
　　　　　　　　　　　　Console.WriteLine("Line　4　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　c = a % b;
　　　　　　　　　　　　Console.WriteLine("Line　5　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　//　++Erhöhen Sie den Wert von a und weisen Sie ihn dann zu
　　　　　　　　　　　　c =　++a;
　　　　　　　　　　　　Console.WriteLine("Line　6　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　//　Der Wert von a ist zu diesem Zeitpunkt　22
　　　　　　　　　　　　//　--Verringern Sie den Wert von a und weisen Sie ihn dann zu
　　　　　　　　　　　　c =　--a;
　　　　　　　　　　　　Console.WriteLine("Line　7　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Line　1　-　Der Wert von c ist　31
Line　2　-　Der Wert von c ist　11
Line　3　-　Der Wert von c ist　210
Line　4　-　Der Wert von c ist　2
Line　5　-　Der Wert von c ist　1
Line　6　-　Der Wert von c ist　22
Line　7　-　Der Wert von c ist　21

  • c = a++: Zuerst weisen Sie a an c weiter, führen Sie dann die Erhöhung von a durch.

  • c = ++a: Zuerst führen Sie die Erhöhung von a durch, geben Sie a dann an c weiter.

  • c = a--: Zuerst weisen Sie a an c weiter, führen Sie dann die Verringerung von a durch.

  • c = --a: Zuerst führen Sie die Verringerung von a durch, geben Sie a dann an c weiter.

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　1;
　　　　　　　　　　　　int b;
　　　　　　　　　　　　//　a++　Weisen Sie zunächst den Wert zu und erhöhen Sie dann den Wert
　　　　　　　　　　　　b = a++;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　++Erhöhen Sie den Wert von a und weisen Sie ihn dann zu
　　　　　　　　　　　　a =　1;　//　Neu initialisieren Sie a
　　　　　　　　　　　　b =　++a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　a--　Weisen Sie zunächst den Wert zu und verringern Sie dann den Wert
　　　　　　　　　　　　a =　1;　　//　Neu initialisieren Sie a
　　　　　　　　　　　　b = a--;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　--Verringern Sie den Wert von a und weisen Sie ihn dann zu
　　　　　　　　　　　　a =　1;　　//　Neu initialisieren Sie a
　　　　　　　　　　　　b =　--a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Führen Sie das obige Programm aus, das Ausgabergebnis ist:

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

Verhoudingsoperator

Die folgende Tabelle zeigt alle verhoudingsoperatoren, die von C# unterstützt werden. Angenommen, die Variable A Der Wert ist 10, Variable B Der Wert ist 20, dann:

运算符描述示例
==Überprüft, ob die Werte der beiden Operanden gleich sind, sind sie gleich, dann ist die Bedingung wahr.(A == B) ist nicht wahr.
!=Überprüft, ob die Werte der beiden Operanden gleich sind, sind sie nicht gleich, dann ist die Bedingung wahr.(A != B) ist wahr.
>Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist, ist dies der Fall, dann ist die Bedingung wahr.(A > B) ist nicht wahr.
<Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist, ist dies der Fall, dann ist die Bedingung wahr.(A < B) ist wahr.
>=Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist, ist dies der Fall, dann ist die Bedingung wahr.(A >= B) ist nicht wahr.
<=Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist, ist dies der Fall, dann ist die Bedingung wahr.(A <= B) ist wahr.

在线示例

Sehen Sie sich das folgende Beispiel an, um alle verfügbaren verhoudingsoperatoren in C# zu verstehen:

在线示例

using System;
class Program
{
　　static void Main(string[] args)
　　{
　　　　　　int a =;　21;
　　　　　　int b =;　10;
　　　　　　
　　　　　　if (a == b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line　1　-　a gleich b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line　1　-　a nicht gleich b);
　　　　　　}
　　　　　　if (a < b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line　2　-　a kleiner als b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line　2　-　a nicht kleiner als b);
　　　　　　}
　　　　　　if (a > b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line　3　-　a größer als b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Line　3　-　a nicht größer als b);
　　　　　　}
　　　　　　/*　Verändere die Werte von a und b　*/
　　　　　　a =　5;
　　　　　　b =　20;
　　　　　　if (a <= b)
　　　　　　{
　　　　　　　　　Console.WriteLine("Line　4　-　a kleiner oder gleich b);
　　　　　　}
　　　　　　if (b >= a)
　　　　　　{
　　　　　　　　　Console.WriteLine("Line　5　-　b größer oder gleich a);
　　　　　　}
　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Line　1　-　a nicht gleich b
Line　2　-　a nicht kleiner als b
Line　3　-　a größer als b
Line　4　-　a kleiner oder gleich b
Line　5　-　b größer oder gleich a

Logischer Operator

Die folgende Tabelle zeigt alle logischen Operatoren, die von C# unterstützt werden. Angenommen, die Variable A Für den booleschen Wert true, Variable B Für den booleschen Wert false:

运算符描述示例
&&Gekennzeichnet als logischer Und-Operator. Wenn beide Operanden nicht null sind, ist die Bedingung wahr.(A && B) ist falsch.
||Gekennzeichnet als logischer Oder-Operator. Wenn einer der Operanden nicht null ist, ist die Bedingung wahr.(A || B) ist wahr.
!Gekennzeichnet als logischer Nicht-Operator. Verwendet, um den logischen Zustand des Operanden umzukehren. Wenn die Bedingung wahr ist, wird der logische Nicht-Operator ihn auf falsch setzen.!(A && B) ist wahr.

在线示例

Sehen Sie sich das folgende Beispiel an, um alle verfügbaren logischen Operatoren in C# zu verstehen:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　bool a = true;
　　　　　　　　　　　　bool b = true;
　　　　　　　　　　　
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　Console.WriteLine("Line　1　-　Bedingung ist wahr;
　　　　　　　　　　　　}
　　　　　　　　　　　　if (a || b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line　2　-　Bedingung ist wahr;
　　　　　　　　　　　　}
　　　　　　　　　　　　/*　Verändere die Werte von a und b　*/
　　　　　　　　　　　　a = false;
　　　　　　　　　　　　b = true;
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line　3　-　Bedingung ist wahr;
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line　3　-　Bedingung ist nicht wahr);
　　　　　　　　　　　　}
　　　　　　　　　　　　if (!(a && b))
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line　4　-　Bedingung ist wahr;
　　　　　　　　　　　　}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Line　1　-　Bedingung ist wahr
Line　2　-　Bedingung ist wahr
Line　3　-　Bedingung ist nicht wahr
Line　4　-　Bedingung ist wahr

Bit-Operator

Bit-Operator wirken auf Bits und führen die Operationen bitweise aus. Die Wahrheitstabelle für &、| und ^ ist wie folgt:

pqp & qp | qp ^ q
00000
01011
11110
10011

Angenommen, wenn A = 60, und B = 13wird jetzt im BinärfORMAT dargestellt, wie folgt:

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

Die folgende Tabelle zeigt die Bit-Operator, die von C# unterstützt werden. Angenommen, die Variable A Der Wert ist 60, Variable B Der Wert ist 13, dann:

运算符描述示例
&Wenn ein Bit in beiden Operanden gleichzeitig vorhanden ist, kopiert der binäre AND-Operator ein Bit in das Ergebnis.(A & B) wird erhalten 12，daher 0000 1100
|Wenn ein Bit in jedem Operanden vorhanden ist, kopiert der binäre OR-Operator ein Bit in das Ergebnis.(A | B) wird erhalten 61, daher 0011 1101
^Wenn ein Bit in einem Operanden vorhanden ist, aber nicht gleichzeitig in beiden Operanden vorhanden ist, kopiert der binäre XOR-Operator ein Bit in das Ergebnis.(A ^ B) wird erhalten 49, daher 0011 0001
~Der Bit-Not-Operator ist ein einäriger Operator mit einem "Umkehrung"-Effekt, d.h. 0 wird1,1wird auf 0 gesetzt, einschließlich des Zeichenbits.(~A) wird erhalten -61，daher 1100 0011，ist die Komplementform einer signierten Binärzahl.
<<Binärer Linksbewegungsoperator. Der Wert des linken Operanden wird um die Anzahl der Stellen nach links verschoben, die der rechte Operanden angibt.A << 2 wird erhalten 240, daher 1111 0000
>>Binärer Rechtsbewegungsoperator. Der Wert des linken Operanden wird um die Anzahl der Stellen nach rechts verschoben, die der rechte Operanden angibt.A >> 2 wird erhalten 15，daher 0000 1111

在线示例

Sehen Sie sich das folgende Beispiel an, um alle verfügbaren Bit-Operator in C# zu verstehen:

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("Line　1　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　　c = a | b;　　　　　　　　　　　/*　61　= 0011　1101　*/
　　　　　　　　　　　　　Console.WriteLine("Line　2　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　　c = a ^ b;　　　　　　　　　　　/*　49　= 0011　0001　*/
　　　　　　　　　　　　　Console.WriteLine("Line　3　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　　c = ~a;　　　　　　　　　　　　　　　/*-61　=　1100 0011　*/
　　　　　　　　　　　　　Console.WriteLine("Line　4　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　　c = a <<　2;　　　　　/*　240 =　1111　0000　*/
　　　　　　　　　　　　　Console.WriteLine("Line　5　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　　c = a >>　2;　　　　　/*　15　= 0000　1111　*/
　　　　　　　　　　　　　Console.WriteLine("Line　6　-　Der Wert von c ist {0}, c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Line　1　-　Der Wert von c ist　12
Line　2　-　Der Wert von c ist　61
Line　3　-　Der Wert von c ist　49
Line　4　-　Der Wert von c ist　-61
Line　5　-　Der Wert von c ist　240
Line　6　-　Der Wert von c ist　15

Zuweisungsoperator

Die folgende Tabelle zeigt die Zuweisungsoperator, die von C# unterstützt werden:

运算符描述示例
=Einfacher Zuweisungsoperator, der den Wert des rechten Operanden dem linken Operanden zuweistC = A + B wird A + Der Wert von B wird C zugewiesen
+=Der Wert der rechten Operanden wird dem Wert der linken Operanden hinzugefügt und dem linken Operanden zugewiesenC += A 相当于 C = C + A
-=Der Wert der linken Operanden wird um den Wert der rechten Operanden verringert und dem linken Operanden zugewiesenC -= A 相当于 C = C - A
*=Der Wert der rechten Operanden wird mit dem Wert der linken Operanden multipliziert und dem linken Operanden zugewiesenC *= A 相当于 C = C * A
/=Der Wert der linken Operanden wird durch den Wert der rechten Operanden geteilt und dem linken Operanden zugewiesenC /= A 相当于 C = C / A
%=求模且赋值运算符，求两个操作数的模赋值给左边操作数C %= A 相当于 C = C % A
<<=左移且赋值运算符C <<= 2 等同于 C = C << 2
>>=右移且赋值运算符C >>= 2 等同于 C = C >> 2
&=按位与且赋值运算符C &= 2 等同于 C = C & 2
^=按位异或且赋值运算符C ^= 2 等同于 C = C ^ 2
|=按位或且赋值运算符C |= 2 等同于 C = C | 2

在线示例

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

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

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Line　1　-　=　　c 的值　=　21
Line　2　-　+=　　c 的值　=　42
Line　3　-　-=　　c 的值　=　21
Line　4　-　*=　　c 的值　=　441
Line　5　-　/=　　c 的值　=　21
Line　6　-　%=　　c 的值　=　11
Line　7　-　<<=　　c 的值　=　44
Line　8　-　>=　　c 的值　=　11
Line　9　-　&=　　c 的值　=　2
Line　10　-　^=　　c 的值　= 0
Line　11　-　|=　　c 的值　=　2

其他运算符

下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。

运算符描述示例
sizeof()返回数据类型的大小。sizeof(int)，将返回 4.
typeof()返回 class 的类型。typeof(StreamReader);
&返回变量的地址。&a; 将得到变量的实际地址。
*变量的指针。*a; 将指向一个变量。
? :条件表达式如果条件为真 ? 则为 X : 否则为 Y
is判断对象是否为某一类型。If( Ford is Car) 　// 检查 Ford 是否是 Car 类的一个对象。
as强制转换，即使转换失败也不会抛出异常。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();
　　　　　　}
　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

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

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

(a　+　b)　*　c　/　d　Wert ist　90
((a　+　b)　*　c)　/　d　Wert ist　90
(a　+　b)　*　(c　/　d)　Wert ist　{0}　e　90
a　+　(b　*　c)　/　d　Wert ist　50
C#-FileInfoC#-Schnittstelle(Interface)