Unity C#-Operatoren, die Sie kennen sollten

Unity ist eine Spiel-Engine, die den Entwicklern hinsichtlich der Funktionalität viel abnimmt und es ihnen ermöglicht, sich ganz auf den Entwicklungsprozess zu konzentrieren. Es verwendet C# als Hauptprogrammiersprache.

Wie jede Programmiersprache besteht C# aus einer Reihe spezieller Funktionen, Typen, Klassen, Bibliotheken usw., verfügt aber auch über eine Liste spezieller Symbole (Operatoren), von denen jedes seine eigene Funktion hat. In diesem Beitrag werde ich diese Symbole auflisten und erklären, was sie bewirken, damit Sie beim nächsten Öffnen eines Skripts schnell verstehen können, was die einzelnen Teile bedeuten.

Operatoren in C# sind einige spezielle Symbole, die bestimmte Aktionen an Operanden ausführen.

In C# gibt es 6 Arten von integrierten Operatoren: Arithmetische Operatoren, Vergleichsoperatoren, boolesche logische Operatoren, bitweise und Verschiebungsoperatoren, Gleichheitsoperatoren und verschiedene Operatoren. Wenn Sie sie alle kennen, werden Sie sofort ein besserer Programmierer.

1. Rechenzeichen

Die folgenden Operatoren führen arithmetische Operationen mit Operanden numerischer Typen durch:

Unäre Operatoren ++ (Inkrement), -- (Dekrement), + (Plus) und - (Minus).
Binäre Operatoren * (Multiplikation), / (Division), % (Rest), + (Addition) und - (Subtraktion).

Inkrementoperator++

Der "add one"-Operator (oder ++) bedeutet += 1, mit anderen Worten, es ist eine schnelle Möglichkeit, eine ganze Zahl zu einem numerischen Wert hinzuzufügen, ohne zusätzlichen Code eingeben zu müssen. Dieser Operator kann entweder vor dem Wert oder nach dem Wert hinzugefügt werden, was zu einem anderen Verhalten führen würde:

//The result of x++ is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i++); // output: 4
Debug.Log(i);   // output: 5

//The result of ++x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(++a); // output: 3.5
Debug.Log(a);   // output: 3.5

Dekrementierungsoperator –

Der "subtract one"-Operator ist das Gegenteil von ++ (-= 1), was bedeutet, dass er eine ganze Zahl von einem numerischen Wert subtrahiert. Es kann auch vor oder nach einem Wert hinzugefügt werden:

The result of x-- is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i--); // output: 4
Debug.Log(i);   // output: 3

The result of --x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(--a); // output: 1.5
Debug.Log(a);   // output: 1.5

Unäre +- und --Operatoren

Der unäre +-Operator gibt den Wert seines Operanden zurück und der unäre --Operator berechnet die numerische Negation seines Operanden.

Debug.Log(+5);     // output: 5

Debug.Log(-5);     // output: -5
Debug.Log(-(-5));  // output: 5

uint a = 6;
var b = -a;
Debug.Log(b);            // output: -6
Debug.Log(b.GetType());  // output: System.Int64

Debug.Log(-double.NaN);  // output: NaN

Multiplikationsoperator *

Der Multiplikationsoperator * berechnet das multiplizierte Produkt seiner Operanden:

Debug.Log(6 * 3);         // output: 18
Debug.Log(1.5 * 3.5);     // output: 5.25
Debug.Log(0.1m * 24.4m);  // output: 2.44

Divisionsbetreiber /

Der Divisionsoperator / dividiert seinen linken Operanden durch seinen rechten Operanden.

Wenn einer der Operanden dezimal ist, kann ein anderer Operand weder float noch double sein, da weder float noch double implizit in eine Dezimalzahl konvertierbar sind. Sie müssen den Float- oder Double-Operanden explizit in den Dezimaltyp konvertieren.

Debug.Log(13 / 5);    // output: 2
Debug.Log(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Debug.Log((double)a / b);  // output: 2.6

Debug.Log(16.8f / 4.1f);   // output: 4.097561
Debug.Log(16.8d / 4.1d);   // output: 4.09756097560976
Debug.Log(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Rest Operator %

Der Restoperator % berechnet den Rest, nachdem er seinen linken Operanden durch seinen rechten Operanden dividiert hat.

Für die Operanden ganzzahliger Typen ist das Ergebnis von a % b der durch a - (a / b) * b erzeugte Wert

Debug.Log(5 % 4);   // output: 1
Debug.Log(5 % -4);  // output: 1
Debug.Log(-5 % 4);  // output: -1
Debug.Log(-5 % -4); // output: -1

Für die Dezimaloperanden entspricht der Restoperator % dem Restoperator des Typs System.Decimal.

Debug.Log(-5.2f % 2.0f); // output: -1.2
Debug.Log(5.9 % 3.1);    // output: 2.8
Debug.Log(5.9m % 3.1m);  // output: 2.8

Additionsoperator +

Der Additionsoperator + berechnet die Summe seiner Operanden. Sie können den Operator „+“ auch für die Zeichenfolgenverkettung und die Kombination von Delegaten verwenden.

Debug.Log(6 + 5);       // output: 11
Debug.Log(6 + 5.3);     // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 11.3

Subtraktionsoperator -

Der Subtraktionsoperator – subtrahiert seinen rechten Operanden von seinem linken Operanden. Sie können auch den -Operator zum Entfernen von Delegaten verwenden.

Debug.Log(48 - 4);      // output: 44
Debug.Log(6 - 5.3);     // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.2

2. Vergleichsoperatoren

Beim < (less than), > (greater than), <= (less than or equal), and >=-Vergleich (größer oder gleich), auch als relationaler Vergleich bezeichnet, vergleichen Operatoren ihre Operanden. Diese Operatoren werden von allen numerischen Integral- und Gleitkommatypen unterstützt.

Kleiner als Operator <

Der <-Operator gibt true zurück, wenn sein linker Operand kleiner ist als sein rechter Operand, andernfalls false.

Debug.Log(8.0 < 6.1);   // output: False
Debug.Log(6.1 < 6.1);   // output: False
Debug.Log(1.0 < 6.1);   // output: True

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

Größer als Operator >

Der >-Operator gibt true zurück, wenn sein linker Operand größer als sein rechter Operand ist, andernfalls false.

Debug.Log(8.0 > 6.1);   // output: True
Debug.Log(6.1 > 6.1);   // output: False
Debug.Log(1.0 > 6.1);   // output: False

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

Kleiner-gleich-Operator <=

Der <=-Operator gibt true zurück, wenn sein linker Operand kleiner oder gleich seinem rechten Operanden ist, andernfalls false.

Debug.Log(8.0 <= 6.1);   // output: False
Debug.Log(6.1 <= 6.1);   // output: True
Debug.Log(1.0 <= 6.1);   // output: True

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

Größer-gleich-Operator >=

Der Operator >= gibt true zurück, wenn sein linker Operand größer oder gleich seinem rechten Operanden ist, andernfalls false.

Debug.Log(8.0 >= 6.1);   // output: True
Debug.Log(6.1 >= 6.1);   // output: True
Debug.Log(1.0 >= 6.1);   // output: False

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

3. Boolesche logische Operatoren

Die folgenden Operatoren führen logische Operationen mit Bool-Operanden durch:

Einstellig ! (logischer Negations-)Operator.
Binär & (logisches UND), | (logisches ODER) und ^ (logisches Exklusiv-ODER) Operatoren. Diese Operatoren werten immer beide Operanden aus.
Binär && (bedingtes logisches UND) und || (bedingtes logisches ODER) Operatoren. Diese Operatoren werten den rechten Operanden nur aus, wenn dies erforderlich ist.

Logischer Negationsoperator !

Das unäre Präfix ! Der Operator berechnet die logische Negation seines Operanden. Das heißt, es erzeugt wahr, wenn der Operand als falsch ausgewertet wird, und falsch, wenn der Operand als wahr ausgewertet wird.

bool passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

Logischer UND-Operator &

Der &-Operator berechnet das logische UND seiner Operanden. Das Ergebnis von x und y ist wahr, wenn sowohl x als auch y als wahr ausgewertet werden. Andernfalls ist das Ergebnis falsch.

Der &-Operator wertet beide Operanden aus, auch wenn der linke Operand als falsch ausgewertet wird, sodass das Operationsergebnis unabhängig vom Wert des rechten Operanden falsch ist.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Logischer Exklusiv-ODER-Operator ^

Der ^-Operator berechnet das logische Exklusiv-ODER, auch logisches XOR genannt, seiner Operanden. Das Ergebnis von x ^ y ist wahr, wenn x als wahr und y als falsch ausgewertet wird oder x als falsch ausgewertet wird und y als wahr ausgewertet wird. Andernfalls ist das Ergebnis falsch. Das heißt, für die Bool-Operanden berechnet der ^-Operator das gleiche Ergebnis wie der Ungleichheitsoperator !=.

Debug.Log(true ^ true);    // output: False
Debug.Log(true ^ false);   // output: True
Debug.Log(false ^ true);   // output: True
Debug.Log(false ^ false);  // output: False

Logischer ODER-Operator |

Die | Der Operator berechnet das logische ODER seiner Operanden. Das Ergebnis von x | y ist wahr, wenn entweder x oder y als wahr ausgewertet wird, andernfalls ist das Ergebnis falsch.

The | Der Operator wertet beide Operanden aus, auch wenn der linke Operand als wahr ausgewertet wird, sodass das Operationsergebnis unabhängig vom Wert des rechten Operanden wahr ist.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Bedingter logischer UND-Operator &&

Der bedingte logische UND-Operator &&, auch bekannt als "short-circuiting" logischer UND-Operator, berechnet das logische UND seiner Operanden. Das Ergebnis von x && y ist wahr, wenn sowohl x als auch y als wahr ausgewertet werden, andernfalls ist das Ergebnis falsch. Wenn x als falsch ausgewertet wird, wird y nicht ausgewertet.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Debug.Log(a);
// Output:
// False

bool b = true && SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

Bedingter logischer ODER-Operator ||

Der bedingte logische ODER-Operator ||, auch bekannt als "short-circuiting" logischer ODER-Operator, berechnet das logische ODER seiner Operanden. Das Ergebnis von x || y ist wahr, wenn entweder x oder y als wahr ausgewertet wird. Andernfalls ist das Ergebnis falsch. Wenn x als wahr ausgewertet wird, wird y nicht ausgewertet.

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Debug.Log(a);
// Output:
// True

bool b = false || SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

4. Bitweise und Verschiebungsoperatoren

Die folgenden Operatoren führen bitweise Operationen oder Schiebeoperationen mit Operanden vom Typ Integral Numeric oder vom Typ Char durch:

Unärer ~-Operator (bitweises Komplement).
Binäre << (left shift) and >>-Verschiebungsoperatoren (Rechtsverschiebung).
Binär & (logisches UND), | (logisches ODER) und ^ (logisches Exklusiv-ODER) Operatoren

Bitweiser Komplementoperator ~

Der ~-Operator erzeugt ein bitweises Komplement seines Operanden, indem er jedes Bit umkehrt.

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

Linksverschiebungsoperator <<

Der <<-Operator verschiebt seinen linken Operanden um die Anzahl der Bits nach links, die durch seinen rechten Operanden definiert ist. Informationen darüber, wie der rechte Operand die Schichtanzahl definiert, finden Sie im Abschnitt Schichtanzahl der Schichtoperatoren.

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

Rechtsschaltoperator >>

Der >>-Operator verschiebt seinen linken Operanden um die durch seinen rechten Operanden definierte Anzahl von Bits nach rechts.

uint x = 0b_1001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10

Die höherwertigen Leerbitpositionen werden basierend auf dem Typ des linken Operanden wie folgt festgelegt:

Wenn der linke Operand vom Typ int oder long ist, führt der Rechtsverschiebungsoperator eine arithmetische Verschiebung durch: Der Wert des höchstwertigen Bits (das Vorzeichenbit) des linken Operanden wird an das höherwertige leere Bit weitergegeben Positionen. Das heißt, die höherwertigen leeren Bitpositionen werden auf Null gesetzt, wenn der linke Operand nicht negativ ist, und auf Eins, wenn er negativ ist.

int a = int.MinValue;
Debug.Log($"Before: {Convert.ToString(a, toBase: 2)}");

int b = a >> 3;
Debug.Log($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000

Wenn der linke Operand vom Typ uint oder ulong ist, führt der Rechtsverschiebungsoperator eine logische Verschiebung durch: Die höherwertigen leeren Bitpositionen werden immer auf Null gesetzt.

uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Debug.Log($"Before: {Convert.ToString(c, toBase: 2), 32}");

uint d = c >> 3;
Debug.Log($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000

Logischer UND-Operator &

Der &-Operator berechnet das bitweise logische UND seiner ganzzahligen Operanden.

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

Logischer Exklusiv-ODER-Operator ^

Der ^-Operator berechnet das bitweise logische Exklusiv-ODER, auch bekannt als bitweises logisches XOR, seiner ganzzahligen Operanden.

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

Logischer ODER-Operator |

Die | Der Operator berechnet das bitweise logische ODER seiner ganzzahligen Operanden.

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

5. Gleichheitsoperatoren

Die Operatoren == (Gleichheit) und != (Ungleichheit) prüfen, ob ihre Operanden gleich sind oder nicht.

Gleichheitsoperator ==

Der Gleichheitsoperator == gibt true zurück, wenn seine Operanden gleich sind, andernfalls false.

int a = 1 + 2 + 3;
int b = 6;
Debug.Log(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2);  // output: False
Debug.Log(c1 == char.ToLower(c2));  // output: True

Ungleichheitsoperator !=

Der Ungleichheitsoperator != gibt true zurück, wenn seine Operanden ungleich sind, andernfalls false. Für die Operanden der integrierten Typen erzeugt der Ausdruck x != y das gleiche Ergebnis wie der Ausdruck !(x == y).

int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Debug.Log(s1 != s2);  // output: False

object o1 = 2;
object o2 = 2;
Debug.Log(o1 != o2);  // output: True

6. Verschiedene Betreiber

Gängige verschiedene Operatoren sind ?: für bedingte Prüfungen,:: für den Zugriff auf ein Mitglied eines Alias-Namespace und $ für die String-Interpolation.

?: Operator

Der Bedingungsoperator ?:, auch als ternärer Bedingungsoperator bekannt, wertet einen booleschen Ausdruck aus und gibt das Ergebnis eines der beiden Ausdrücke zurück, abhängig davon, ob der boolesche Ausdruck als wahr oder falsch ausgewertet wird, wie das folgende Beispiel zeigt:

bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1

:: Operator

Verwenden Sie den Namespace-Alias-Qualifizierer::, um auf ein Mitglied eines Alias-Namespace zuzugreifen. Sie können das Qualifikationsmerkmal:: nur zwischen zwei Bezeichnern verwenden. Der linke Bezeichner kann einer der folgenden Aliase sein:

Ein Namespace-Alias, der mit einer using-Alias-Direktive erstellt wurde:

using forwinforms = System.Drawing;
using forwpf = System.Windows;

public class Converters
{
    public static forwpf::Point Convert(forwinforms::Point point) => new forwpf::Point(point.X, point.Y);
}

Ein externer Alias.
Der globale Alias, der der globale Namespace-Alias ist. Der globale Namespace ist der Namespace, der Namespaces und Typen enthält, die nicht innerhalb eines benannten Namespace deklariert sind. Bei Verwendung mit dem Qualifikationsmerkmal:: verweist der globale Alias immer auf den globalen Namespace, auch wenn es einen benutzerdefinierten globalen Namespace-Alias gibt.

namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

$-Operator

Das Sonderzeichen $ identifiziert ein String-Literal als interpolierten String. Eine interpolierte Zeichenfolge ist ein Zeichenfolgenliteral, das Interpolationsausdrücke enthalten kann. Wenn eine interpolierte Zeichenfolge in eine Ergebniszeichenfolge aufgelöst wird, werden Elemente mit Interpolationsausdrücken durch die Zeichenfolgendarstellungen der Ausdrucksergebnisse ersetzt.

In interpolierten Zeichenfolgen wird das Dollarzeichen ($) verwendet, um dem C#-Compiler mitzuteilen, dass die darauf folgende Zeichenfolge als interpolierte Zeichenfolge interpretiert werden soll. Die geschweiften Klammern kapseln die Werte (der Variablen), die in den Text aufgenommen werden sollen.

Um ein String-Literal als interpolierten String zu kennzeichnen, stellen Sie ihm das $-Symbol voran. Zwischen dem $ und dem „, mit dem ein String-Literal beginnt, darf kein Leerzeichen stehen.

string name = "John";
var date = DateTime.Now;
Debug.Log($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Output:
// Hello, John! Today is Wednesday, it's 19:40 now.

Unity Unity3D Csharp Programmierung Operatoren Microsoft Windows Dotnet