C# Operatoren: Umfassender Leitfaden zu allen Operatorarten

Überblick

Ein Operator ist ein Symbol, das den Compiler anweist, eine bestimmte mathematische oder logische Operation auszuführen. C# bietet folgende Operator-Kategorien:

Arithmetische Operatoren
Relationale (Vergleichs-) Operatoren
Logische Operatoren
Bitweise Operatoren
Zuweisungsoperatoren
Sonstige Operatoren (sizeof, typeof, ?:, is, as, …)

Arithmetische Operatoren

Angenommen A = 10, B = 20:

Operator	Beschreibung	Beispiel
`+`	Addition	`A + B = 30`
`-`	Subtraktion	`A - B = -10`
`*`	Multiplikation	`A * B = 200`
`/`	Division	`B / A = 2`
`%`	Modulo (Rest)	`B % A = 0`
`++`	Inkrement	`A++ = 11`
`--`	Dekrement	`A-- = 9`

Relationale Operatoren

Liefern bool-Ergebnis. A = 10, B = 20:

Operator	Beschreibung	Beispiel
`==`	Gleichheit	`(A == B) → false`
`!=`	Ungleichheit	`(A != B) → true`
`>`	Größer als	`(A > B) → false`
`<`	Kleiner als	`(A < B) → true`
`>=`	Größer oder gleich	`(A >= B) → false`
`<=`	Kleiner oder gleich	`(A <= B) → true`

Logische Operatoren

Arbeiten mit bool-Werten. A = true, B = false:

Operator	Beschreibung	Beispiel
`&&`	Logisches UND (Kurzschluss)	`(A && B) → false`
`\|\|`	Logisches ODER (Kurzschluss)	`(A \|\| B) → true`
`!`	Logisches NICHT	`!(A && B) → true`

Bitweise Operatoren

Arbeiten auf Bit-Ebene. A = 60 (0011 1100), B = 13 (0000 1101):

Operator	Beschreibung	Beispiel
`&`	Bitweises UND	`A & B = 12 (0000 1100)`
`\|`	Bitweises ODER	`A \| B = 61 (0011 1101)`
`^`	Bitweises XOR	`A ^ B = 49 (0011 0001)`
`~`	Ein-Komplement (Bit-NOT)	`~A = -61 (1100 0011 in 2er-Komplement)`
`<<`	Links-Shift	`A << 2 = 240 (1111 0000)`
`>>`	Rechts-Shift	`A >> 2 = 15 (0000 1111)`

Zuweisungsoperatoren

Operator	Beschreibung	Äquivalent
`=`	Einfache Zuweisung	`C = A + B`
`+=`	Addieren & zuweisen	`C += A → C = C + A`
`-=`	Subtrahieren & zuweisen	`C -= A → C = C - A`
`*=`	Multiplizieren & zuweisen	`C = A → C = C A`
`/=`	Dividieren & zuweisen	`C /= A → C = C / A`
`%=`	Modulo & zuweisen	`C %= A → C = C % A`
`<<=`	Links-Shift & zuweisen	`C <<= 2 → C = C << 2`
`>>=`	Rechts-Shift & zuweisen	`C >>= 2 → C = C >> 2`
`&=`	Bit-UND & zuweisen	`C &= 2 → C = C & 2`
`^=`	Bit-XOR & zuweisen	`C ^= 2 → C = C ^ 2`
`\|=`	Bit-ODER & zuweisen	`C \|= 2 → C = C \| 2`

Sonstige wichtige Operatoren

Operator	Beschreibung	Beispiel
`sizeof()`	Größe eines Typs in Bytes	`sizeof(int) → 4`
`typeof()`	Typ-Objekt zur Laufzeit	`typeof(string)`
`&`	Adresse (nur `unsafe`)	`&x`
`*`	Zeiger-Dereferenzierung (nur `unsafe`)	`*p`
`?:`	Ternärer Bedingungsoperator	`cond ? wert1 : wert2`
`is`	Typprüfung zur Laufzeit	`obj is string`
`as`	Sicheres Casting (gibt `null` bei Fehlschlag)	`obj as string`

Operator-Rangfolge (Precedence)

Operatoren mit höherer Rangfolge werden zuerst ausgewertet. Beispiel: x = 7 + 3 * 2 → 3*2 zuerst, dann +7, Ergebnis 13.

Die folgende Tabelle listet Kategorien von höchster (oben) zu niedrigster (unten) Rangfolge. Innerhalb einer Kategorie gilt die angegebene Assoziativität.

Kategorie	Operatoren	Assoziativität
Postfix	`() [] -> . ++ --`	Links nach rechts
Unär	`+ - ! ~ ++ -- (type)* & sizeof`	Rechts nach links
Multiplikativ	`* / %`	Links nach rechts
Additiv	`+ -`	Links nach rechts
Shift	`<< >>`	Links nach rechts
Relational	`< <= > >=`	Links nach rechts
Gleichheit	`== !=`	Links nach rechts
Bitweises UND	`&`	Links nach rechts
Bitweises XOR	`^`	Links nach rechts
Bitweises ODER	`\|`	Links nach rechts
Logisches UND	`&&`	Links nach rechts
Logisches ODER	`\|\|`	Links nach rechts
Bedingung	`?:`	Rechts nach links
Zuweisung	`= += -= *= /= %= >>= <<= &= ^= \|=`	Rechts nach links
Komma	`,`	Links nach rechts

C# Konstanten & Literale: Typen, Regeln und Best Practices Entscheidungsstrukturen in C#: if, else, switch & Ternärer Operator

C Sprache