C#-Operatoren

In diesem Artikel erfahren wir alles über verschiedene Arten von Operatoren in der Programmiersprache C# und wie man sie verwendet.

Operatoren sind Symbole, die zum Ausführen von Operationen an Operanden verwendet werden. Operanden können Variablen und/oder Konstanten sein.

Zum Beispiel , in 2+3 , + ist ein Operator, der verwendet wird, um Additionsoperationen auszuführen, während 2 und 3 sind Operanden.

Operatoren werden verwendet, um Variablen und Werte in einem Programm zu manipulieren. C# unterstützt eine Reihe von Operatoren, die basierend auf der Art der von ihnen durchgeführten Operationen klassifiziert werden.

1. Grundlegender Zuweisungsoperator

Der einfache Zuweisungsoperator (=) wird verwendet, um Variablen Werte zuzuweisen. Zum Beispiel

double x;
x = 50.05;

Hier wird x 50.05 zugewiesen.

Beispiel 1:Grundlegender Zuweisungsoperator

using System;

namespace Operator
{
	class AssignmentOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber, secondNumber;
			// Assigning a constant to variable
			firstNumber = 10;
			Console.WriteLine("First Number = {0}", firstNumber);

			// Assigning a variable to another variable
			secondNumber = firstNumber;
			Console.WriteLine("Second Number = {0}", secondNumber);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

First Number = 10
Second Number = 10

Dies ist ein einfaches Beispiel, das die Verwendung des Zuweisungsoperators demonstriert.

Vielleicht ist Ihnen die Verwendung von geschweiften Klammern { } aufgefallen im Beispiel. Wir werden darüber in String-Formatierung diskutieren . Denken Sie vorerst nur an {0} wird durch die erste Variable ersetzt, die der Zeichenfolge folgt, {1} wird durch die zweite Variable ersetzt und so weiter.

2. Arithmetische Operatoren

Arithmetische Operatoren werden verwendet, um arithmetische Operationen wie Addition, Subtraktion, Multiplikation, Division usw. auszuführen.

Zum Beispiel

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

Arithmetische C#-Operatoren
Operator	Operatorname	Beispiel
+	Additionsoperator	6 + 3 ergibt 9
-	Subtraktionsoperator	10 - 6 ergibt 4
*	Multiplikationsoperator	4 * 2 ergibt 8
/	Divisionsoperator	10/5 ergibt 2
%	Modulo-Operator (Rest)	16 % 3 ergibt 1

Beispiel 2:Arithmetische Operatoren

using System;
 
namespace Operator
{
	class ArithmeticOperator
	{
		public static void Main(string[] args)
		{
			double firstNumber = 14.40, secondNumber = 4.60, result;
			int num1 = 26, num2 = 4, rem;

			// Addition operator
			result = firstNumber + secondNumber;
			Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

			// Subtraction operator
			result = firstNumber - secondNumber;
			Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

			// Multiplication operator
			result = firstNumber * secondNumber;
			Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

			// Division operator
			result = firstNumber / secondNumber;
			Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

			// Modulo operator
			rem = num1 % num2;
			Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Im obigen Beispiel werden arithmetische Operationen durchgeführt. Variablen können in den Anweisungen durch Konstanten ersetzt werden. Zum Beispiel

result = 4.5 + 2.7 ; // result will hold 7.2
result = firstNumber - 3.2; // result will hold 11.2

3. Vergleichsoperatoren

Vergleichsoperatoren werden verwendet, um die Beziehung zwischen zwei Operanden zu überprüfen. Wenn die Beziehung wahr ist, ist das Ergebnis true , andernfalls ergibt es false .

Vergleichsoperatoren werden in Entscheidungsfindungen und Schleifen verwendet.

Relationale C#-Operatoren
Operator	Operatorname	Beispiel
==	Gleich	6 ==4 wird als falsch ausgewertet
>	Größer als	3> -1 ergibt wahr
<	Kleiner als	5 <3 wird als falsch ausgewertet
>=	Größer als oder gleich	4>=4 ergibt wahr
<=	Kleiner als oder gleich	5 <=3 wird als falsch ausgewertet
!=	Ungleich	10 !=2 ergibt wahr

Beispiel 3:Vergleichsoperatoren

using System;
 
namespace Operator
{
	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);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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 werden verwendet, um logische Operationen wie and auszuführen , or . Logische Operatoren arbeiten mit booleschen Ausdrücken (true und false ) und gibt boolesche Werte zurück. Logische Operatoren werden in Entscheidungsfindungen und Schleifen verwendet.

So wird das Ergebnis für logisch AND ausgewertet und OR Betreiber.

Logische C#-Operatoren
Operand 1	Operand 2	ODER (\|\|)	UND (&&)
wahr	wahr	wahr	wahr
wahr	falsch	wahr	falsch
falsch	wahr	wahr	falsch
falsch	falsch	falsch	falsch

In einfachen Worten kann die Tabelle wie folgt zusammengefasst werden:

Wenn einer der Operanden wahr ist, wird der OR Operator wertet es zu true aus .
Wenn einer der Operanden falsch ist, wird der AND Operator wertet es zu false aus .

Beispiel 4:Logische Operatoren

using System;
 
namespace Operator
{
	class LogicalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			// OR operator
			result = (firstNumber == secondNumber) || (firstNumber > 5);
			Console.WriteLine(result);

			// AND operator
			result = (firstNumber == secondNumber) && (firstNumber > 5);
			Console.WriteLine(result);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

True
False

5. Unäre Operatoren

Im Gegensatz zu anderen Operatoren arbeiten die unären Operatoren mit einem einzelnen Operanden.

Unäre C#-Operatoren
Operator	Operatorname	Beschreibung
+	Unary Plus	Belässt das Vorzeichen des Operanden wie es ist
-	Unäres Minus	Invertiert das Vorzeichen des Operanden
++	Erhöhen	Wert um 1 erhöhen
--	Verringern	Wert um 1 verringern
!	Logische Negation (nicht)	Invertiert den Wert eines booleschen Werts

Beispiel 5:Unäre Operatoren

using System;
 
namespace Operator
{
	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));
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Das Inkrement (++) und dekrementiere (--) Operatoren können als Präfix und Postfix verwendet werden. Bei Verwendung als Präfix wird die Wertänderung der Variablen in derselben Zeile angezeigt, und bei Verwendung als Postfix wird die Wertänderung der Variable in der nächsten Zeile angezeigt. Dies wird durch das folgende Beispiel deutlich.

Beispiel 6:Post- und Pre-Increment-Operatoren in C#

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			Console.WriteLine((number++));
			Console.WriteLine((number));

			Console.WriteLine((++number));
			Console.WriteLine((number));
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

Wir können den Effekt der Verwendung von ++ sehen als Präfix und Postfix. Wenn ++ nach dem Operanden verwendet wird, wird der Wert zuerst ausgewertet und dann um 1 erhöht . Daher die Aussage

Console.WriteLine((number++));

gibt 10 aus statt 11 . Nachdem der Wert gedruckt wurde, wird der Wert von Zahl um 1 erhöht .

Der Prozess ist umgekehrt, wenn ++ wird als Präfix verwendet. Der Wert wird vor dem Drucken erhöht. Daher die Aussage

Console.WriteLine((++number));

gibt 12 aus .

Der gleiche Fall gilt für den Dekrementoperator (--) .

6. Ternärer Operator

Der ternäre Operator ? : arbeitet mit drei Operanden. Es ist eine Abkürzung für if-then-else Aussage. Der ternäre Operator kann wie folgt verwendet werden:

variable = Condition? Expression1 : Expression2;

Der ternäre Operator funktioniert wie folgt:

Wenn der von Bedingung angegebene Ausdruck true ist , das Ergebnis von Ausdruck1 wird Variable zugewiesen.
Wenn es false ist , das Ergebnis von Expression2 wird Variable zugewiesen.

Beispiel 7:Ternärer Operator

using System;
 
namespace Operator
{
	class TernaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;
			string result;

			result = (number % 2 == 0)? "Even Number" : "Odd Number";
			Console.WriteLine("{0} is {1}", number, result);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

10 is Even Number

Weitere Informationen finden Sie unter ternärer C#-Operator .

7. Bitwise- und Bit-Shift-Operatoren

Bitweise und Bitverschiebungsoperatoren werden verwendet, um Bitmanipulationsoperationen durchzuführen.

Bitwise- und Bit-Shift-Operatoren in C#
Operator	Operatorname
~	Bitweise Ergänzung
&	Bitweises UND
\|	Bitweises ODER
^	Bitweises exklusives ODER
<<	Bitweise Verschiebung nach links
>>	Bitweise Rechtsverschiebung

Beispiel 8:Bitweiser und Bitverschiebungsoperator

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber = 10;
			int secondNumber = 20;
			int 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);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

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

Weitere Informationen finden Sie unter C# Bitwise and Bit Shift operator .

8. Zusammengesetzte Zuweisungsoperatoren

Zusammengesetzte Zuweisungsoperatoren in C#
Operator	Operatorname	Beispiel	Äquivalent zu
+=	Zusatzauftrag	`x += 5`	`x = x + 5`
-=	Subtraktionszuweisung	`x -= 5`	`x = x - 5`
*=	Multiplikationszuweisung	`x *= 5`	`x = x * 5`
/=	Abteilungszuweisung	`x /= 5`	`x = x / 5`
%=	Modulo-Zuweisung	`x %= 5`	`x = x % 5`
&=	Bitweise UND-Zuweisung	`x &= 5`	`x = x & 5`
\|=	Bitweise ODER-Zuweisung	`x \|= 5`	`x = x \| 5`
^=	Bitweise XOR-Zuweisung	`x ^= 5`	`x = x ^ 5`
<<=	Linke Schichtzuweisung	`x <<= 5`	`x = x << 5`
>>=	Rechtsschichtzuweisung	`x >>= 5`	`x = x >> 5`
=>	Lambda-Operator	`x => x*x`	`Returns x*x`

Beispiel 9:Zusammengesetzter Zuweisungsoperator

using System;
 
namespace Operator
{
	class BitOperator
	{
		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);
		}
	}
}

Wenn wir das Programm ausführen, lautet die Ausgabe:

Wir werden über Lambda-Operatoren diskutieren im späteren Tutorial.

C#-Variablen und (primitive) Datentypen Vorrang und Assoziativität von C#-Operatoren

C Sprache