C# Operatoren – Umfassender Leitfaden zu Operatoren in C#

C# Operatoren

Erkunden Sie jede Operator-Kategorie in C# und lernen Sie, sie effektiv in Ihrem Code anzuwenden.

Operatoren sind Symbole, die Aktionen auf einem oder mehreren Operanden – Variablen, Konstanten oder Ausdrücken – ausführen. In C# sind Operatoren nach der Art der Operation gruppiert, wie arithmetisch, logisch, bitweise und mehr.

1. Basis-Zuweisungsoperator

Der Zuweisungsoperator (=) speichert einen Wert in einer Variable.

double x;
x = 50.05;

Beispiel 1: Zuweisungsoperator verwenden

using System;
namespace OperatorDemo
{
    class AssignmentOperator
    {
        public static void Main(string[] args)
        {
            int firstNumber, secondNumber;
            firstNumber = 10;
            Console.WriteLine("First Number = {0}", firstNumber);
            secondNumber = firstNumber;
            Console.WriteLine("Second Number = {0}", secondNumber);
        }
    }
}

Output:

First Number = 10
Second Number = 10

2. Arithmetische Operatoren

Arithmetische Operatoren führen mathematische Berechnungen durch.

int x = 5;
int y = 10;
int z = x + y; // z = 15

C# Arithmetische Operatoren
Operator	Name	Beispiel
+	Addition	6 + 3 = 9
-	Subtraktion	10 - 6 = 4
*	Multiplikation	4 * 2 = 8
/	Division	10 / 5 = 2
%	Modulo (Rest)	16 % 3 = 1

Beispiel 2: Arithmetische Operationen

using System;
namespace OperatorDemo
{
    class ArithmeticOperator
    {
        public static void Main(string[] args)
        {
            double firstNumber = 14.40, secondNumber = 4.60, result;
            int num1 = 26, num2 = 4, rem;
            result = firstNumber + secondNumber;
            Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber - secondNumber;
            Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber * secondNumber;
            Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber / secondNumber;
            Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);
            rem = num1 % num2;
            Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
        }
    }
}

Output:

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

3. Relationale Operatoren

Diese Operatoren vergleichen zwei Operanden und geben ein Boolean-Ergebnis zurück.

C# Relationale Operatoren
Operator	Name	Beispiel
==	Gleich	6 == 4 → false
>	Größer als	3 > -1 → true
<	Kleiner als	5 < 3 → false
>=	Größer oder gleich	4 >= 4 → true
<=	Kleiner oder gleich	5 <= 3 → false
!=	Ungleich	10 != 2 → true

Beispiel 3: Relationale Prüfungen

using System;
namespace OperatorDemo
{
    class RelationalOperator
    {
        public static void Main(string[] args)
        {
            bool result;
            int firstNumber = 10, secondNumber = 20;
            result = (firstNumber == secondNumber);
            Console.WriteLine("{0} == {1} returns {2}", firstNumber, secondNumber, result);
            result = (firstNumber > secondNumber);
            Console.WriteLine("{0} > {1} returns {2}", firstNumber, secondNumber, result);
            result = (firstNumber < secondNumber);
            Console.WriteLine("{0} < {1} returns {2}", firstNumber, secondNumber, result);
            result = (firstNumber >= secondNumber);
            Console.WriteLine("{0} >= {1} returns {2}", firstNumber, secondNumber, result);
            result = (firstNumber <= secondNumber);
            Console.WriteLine("{0} <= {1} returns {2}", firstNumber, secondNumber, result);
            result = (firstNumber != secondNumber);
            Console.WriteLine("{0} != {1} returns {2}", firstNumber, secondNumber, result);
        }
    }
}

Output:

10 == 20 returns False
10 > 20 returns False
10 < 20 returns True
10 >= 20 returns False
10 <= 20 returns True
10 != 20 returns True

4. Logische Operatoren

Logische Operatoren evaluieren Boolean-Ausdrücke.

C# Logische Operatoren
Operand 1	Operand 2	OR (\|\|)	AND (&&)
true	true	true	true
true	false	true	false
false	true	true	false
false	false	false	false

Ist einer der Operanden true, liefert OR true.
Beide Operanden müssen true sein, damit AND true zurückgibt.

Beispiel 4: Logische Operatoren

using System;
namespace OperatorDemo
{
    class LogicalOperator
    {
        public static void Main(string[] args)
        {
            bool result;
            int firstNumber = 10, secondNumber = 20;
            result = (firstNumber == secondNumber) || (firstNumber > 5);
            Console.WriteLine(result);
            result = (firstNumber == secondNumber) && (firstNumber > 5);
            Console.WriteLine(result);
        }
    }
}

Output:

True
False

5. Unäre Operatoren

Unäre Operatoren wirken auf einen einzelnen Operanden.

C# Unäre Operatoren
Operator	Name	Beschreibung
+	Unäres Plus	Lässt Vorzeichen unverändert
-	Unäres Minus	Negiert Vorzeichen
++	Inkrement	Erhöht um 1
--	Dekrement	Verringert um 1
!	Logisches NOT	Invertiert Boolean

Beispiel 5: Unäre Operatoren

using System;
namespace OperatorDemo
{
    class UnaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10, result;
            bool flag = true;
            result = +number;
            Console.WriteLine("+number = " + result);
            result = -number;
            Console.WriteLine("-number = " + result);
            result = ++number;
            Console.WriteLine("++number = " + result);
            result = --number;
            Console.WriteLine("--number = " + result);
            Console.WriteLine("!flag = " + (!flag));
        }
    }
}

Output:

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

Beispiel 6: Präfix vs. Postfix-Inkrement

using System;
namespace OperatorDemo
{
    class UnaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            Console.WriteLine(number++); // 10
            Console.WriteLine(number);   // 11
            Console.WriteLine(++number); // 12
            Console.WriteLine(number);   // 12
        }
    }
}

Output:

6. Ternärer Operator

Der ternäre Operator (? :) kondensiert ein if-else-Statement in eine einzelne Zeile.

variable = Condition ? Expression1 : Expression2;

Ist Condition true, wird Expression1 evaluiert; andernfalls Expression2.

Beispiel 7: Ternären Operator nutzen

using System;
namespace OperatorDemo
{
    class TernaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            string result = (number % 2 == 0) ? "Even Number" : "Odd Number";
            Console.WriteLine("{0} is {1}", number, result);
        }
    }
}

Output:

10 is Even Number

Mehr zum C# ternären Operator.

7. Bitweise & Bit-Shift-Operatoren

Diese Operatoren manipulieren einzelne Bits von Integral-Typen.

C# Bitweise & Bit-Shift-Operatoren
Operator	Name
~	Bitweises Komplement
&	UND
\|	ODER
^	XOR
<<	Links-Shift
>>	Rechts-Shift

Beispiel 8: Bitweise Operationen

using System;
namespace OperatorDemo
{
    class BitOperator
    {
        public static void Main(string[] args)
        {
            int firstNumber = 10, secondNumber = 20, result;
            result = ~firstNumber;
            Console.WriteLine("~{0} = {1}", firstNumber, result);
            result = firstNumber & secondNumber;
            Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber | secondNumber;
            Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber ^ secondNumber;
            Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber << 2;
            Console.WriteLine("{0} << 2 = {1}", firstNumber, result);
            result = firstNumber >> 2;
            Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
        }
    }
}

Output:

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

Für tiefere Einblicke besuchen Sie den C# Bitwise and Bit Shift operators Guide.

8. Kombinierte Zuweisungsoperatoren

Diese Operatoren kombinieren eine arithmetische Operation mit Zuweisung.

C# Kombinierte Zuweisungsoperatoren
Operator	Name	Beispiel	Äquivalent zu
+=	Additionszuweisung	`x += 5`	`x = x + 5`
-=	Subtraktionszuweisung	`x -= 5`	`x = x - 5`
*=	Multiplikationszuweisung	`x *= 5`	`x = x * 5`
/=	Divisionszuweisung	`x /= 5`	`x = x / 5`
%=	Modulozweisung	`x %= 5`	`x = x % 5`
&=	Bitweises UND-Zuweisung	`x &= 5`	`x = x & 5`
\|=	Bitweises ODER-Zuweisung	`x \|= 5`	`x = x \| 5`
^=	Bitweises XOR-Zuweisung	`x ^= 5`	`x = x ^ 5`
<<=	Links-Shift-Zuweisung	`x <<= 5`	`x = x << 5`
>>=	Rechts-Shift-Zuweisung	`x >>= 5`	`x = x >> 5`
=>	Lambda-Operator	`x => x * x`	Gibt x² zurück

Beispiel 9: Kombinierte Zuweisung nutzen

using System;
namespace OperatorDemo
{
    class CompoundOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            number += 5;
            Console.WriteLine(number);
            number -= 3;
            Console.WriteLine(number);
            number *= 2;
            Console.WriteLine(number);
            number /= 3;
            Console.WriteLine(number);
            number %= 3;
            Console.WriteLine(number);
            number &= 10;
            Console.WriteLine(number);
            number |= 14;
            Console.WriteLine(number);
            number ^= 12;
            Console.WriteLine(number);
            number <<= 2;
            Console.WriteLine(number);
            number >>= 3;
            Console.WriteLine(number);
        }
    }
}

Output:

Spätere Tutorials werden Lambda-Ausdrücke detailliert behandeln.

C# Variablen & Primitive Datentypen meistern: Der komplette Guide C# Operator-Rangfolge und Assoziativität meistern: Ein praktischer Leitfaden

C Sprache