Unity C# - Unverzichtbare Operatoren

Unity ist eine Game-Engine, die Entwicklern in Sachen Funktionalität viel "heavy-lifting" abnimmt und ihnen ermöglicht, sich ganz auf den Entwicklungsprozess zu konzentrieren. Sie verwendet C# als Hauptprogrammiersprache.

Wie jede Programmiersprache besteht C# aus einer Reihe von Spezialfunktionen, Typen, Klassen, Bibliotheken usw., verfügt aber auch über eine Liste von Spezialsymbolen (Operatoren), die jeweils eine eigene Funktion haben. In diesem Beitrag werde ich diese Symbole auflisten und erklären, was sie tun, damit Sie beim nächsten Öffnen eines Skripts schnell verstehen, was die einzelnen Teile bedeuten.

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

In C# gibt es 6 Arten von integrierten Operatoren: Arithmetikoperatoren, Vergleichsoperatoren, Boolesche logische Operatoren, Bit- und Verschiebeoperatoren, Gleichheitsoperatoren und sonstige Operatoren. Wenn Sie sie alle kennen, werden Sie sofort ein besserer Programmierer.

1. Arithmetische Operatoren

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

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

Inkrementoperator ++

Der Operator "add one" (oder ++) bedeutet += 1. Mit anderen Worten ist dies eine schnelle Möglichkeit, einem numerischen Wert eine Ganzzahl hinzuzufügen, ohne zusätzlichen Code eingeben zu müssen. Dieser Operator kann entweder vor 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

Dekrementoperator --

Der Operator "subtract one" ist das Gegenteil von ++ (-= 1), d. h. er subtrahiert eine Ganzzahl von einem numerischen Wert. Er 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

Bereichsleiter /

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 dezimal konvertierbar sind. Sie müssen den Float- oder Double-Operanden explizit in den dezimalen Typ 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

Restoperator %

Der Restoperator % berechnet den Rest nach der Division seines linken Operanden durch seinen rechten Operanden.

Für Operanden ganzer Typen ist das Ergebnis von a % b der Wert, der durch a - (a / b) * b erzeugt wird.

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 ist der Restoperator % gleichwertig mit 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 zur Zeichenfolgenverkettung und Delegatkombination 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 den - Operator auch 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

Der < (less than), > (greater than), <= (less than or equal), and >= (größer als oder gleich) Vergleichsoperator, auch als relationaler Operator bekannt, vergleicht seine Operanden. Diese Operatoren werden von allen ganzzahligen und Gleitkomma-Zahlentypen unterstützt.

Kleiner-als-Operator <

Der Operator < gibt „true“ zurück, wenn sein linker Operand kleiner als sein rechter Operand ist, 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-als-oder-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-als- oder 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 aus:

Unärer !-Operator (logische Negation).
Binäre Operatoren & (logisches UND), | (logisches ODER) und ^ (logisches exklusives ODER). Diese Operatoren werten immer beide Operanden aus.
Binäre Operatoren && (bedingtes logisches UND) und || (bedingtes logisches ODER). Diese Operatoren werten den rechten Operanden nur aus, wenn dies erforderlich ist.

Logischer Negationsoperator !

Der unäre Präfix-Operator ! berechnet die logische Negation seines Operanden. Das heißt, er erzeugt „true“, wenn der Operand als „false“ ausgewertet wird, und „false“, wenn der Operand als „true“ 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 & 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 exklusive ODER (auch als logisches XOR bekannt) seiner Operanden. Das Ergebnis von x ^ y ist wahr, wenn x als wahr und y als falsch ausgewertet wird oder wenn x als falsch und y als wahr ausgewertet wird. Andernfalls ist das Ergebnis falsch. Das heißt, für die booleschen Operanden berechnet der ^-Operator dasselbe 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 |

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.

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 Verschiebeoperationen mit Operanden der ganzzahligen numerischen Typen oder des Typs char aus:

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

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 wird. Informationen dazu, wie der rechte Operand die Verschiebungsanzahl definiert, finden Sie im Abschnitt Verschiebungsanzahl der Verschiebungsoperatoren.

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

Rechtsverschiebungsoperator >>

Der Operator >> verschiebt seinen linken Operanden um die Anzahl Bits nach rechts, die durch seinen rechten Operanden definiert ist.

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öchstwertigen leeren Bitpositionen 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 aus: Der Wert des höchstwertigen Bits (des Vorzeichenbits) des linken Operanden wird an die höchstwertigen leeren Bitpositionen weitergegeben. Das heißt, die höchstwertigen leeren Bitpositionen werden auf 0 gesetzt, wenn der linke Operand nicht negativ ist, und auf 1, 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 aus: Die höchstwertigen 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 exklusive ODER (auch als bitweises logisches XOR bezeichnet) 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 |

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 dasselbe 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 Operatoren

Häufige sonstige Operatoren sind ?: für bedingte Überprüfungen, :: für den Zugriff auf ein Mitglied eines Alias-Namespaces und $ für die Zeichenfolgeninterpolation.

?: 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 „true“ oder „false“ ausgewertet wird, wie das folgende Beispiel zeigt:

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

:: Betreiber

Verwenden Sie den Namespace-Alias-Qualifizierer::, um auf ein Mitglied eines Alias-Namespace zuzugreifen. Sie können den Qualifizierer:: 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 Qualifizierer:: verweist der globale Alias immer auf den globalen Namespace, selbst wenn der benutzerdefinierte globale Namespace-Alias vorhanden ist.

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 einen Zeichenfolgenliteral als interpolierte Zeichenfolge. Eine interpolierte Zeichenfolge ist eine Zeichenfolgenliteral, die 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 folgende Zeichenfolge als interpolierte Zeichenfolge interpretiert werden soll. Die geschweiften Klammern kapseln die Werte (der Variablen) ein, die in den Text aufgenommen werden sollen.

Um einen Zeichenfolgenliteral als interpolierte Zeichenfolge zu identifizieren, stellen Sie ihm das Symbol $ voran. Zwischen dem $ und dem ", mit dem ein Zeichenfolgenliteral 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