AusdrückeExpressions

Ausdrücke bestehen aus Operanden und Operatoren.Expressions are constructed from operands and operators. Die Operatoren eines Ausdrucks geben an, welche Operationen auf die Operanden angewendet werden.The operators of an expression indicate which operations to apply to the operands. Beispiele für Operatoren sind +, -, *, / und new.Examples of operators include +, -, *, /, and new. Beispiele für Operanden sind Literale, Felder, lokale Variablen und Ausdrücke.Examples of operands include literals, fields, local variables, and expressions.

Wenn ein Ausdruck mehrere Operatoren enthält, bestimmt die Rangfolge der Operatoren die Reihenfolge, in der die einzelnen Operatoren ausgewertet werden.When an expression contains multiple operators, the precedence of the operators controls the order in which the individual operators are evaluated. Der Ausdruck x + y * z wird z.B. als x + (y * z) ausgewertet, da der *-Operator Vorrang vor dem +-Operator hat.For example, the expression x + y * z is evaluated as x + (y * z) because the * operator has higher precedence than the + operator.

Tritt ein Operand zwischen zwei Operatoren mit gleicher Rangfolge auf, steuert die Assoziativität der Operatoren die Reihenfolge, in der die Vorgänge ausgeführt werden:When an operand occurs between two operators with the same precedence, the associativity of the operators controls the order in which the operations are performed:

  • Mit Ausnahme der Zuweisungsoperatoren sind alle binären Operatoren linksassoziativ, was bedeutet, dass Vorgänge von links nach rechts ausgeführt werden.Except for the assignment operators, all binary operators are left-associative, meaning that operations are performed from left to right. x + y + z wird beispielsweise als (x + y) + z ausgewertet.For example, x + y + z is evaluated as (x + y) + z.
  • Die Zuweisungsoperatoren und der bedingte Operator (?:) sind rechtsassoziativ, d.h., die Operationen werden von rechts nach links ausgeführt.The assignment operators and the conditional operator (?:) are right-associative, meaning that operations are performed from right to left. x = y = z wird beispielsweise als x = (y = z) ausgewertet.For example, x = y = z is evaluated as x = (y = z).

Rangfolge und Assoziativität können mit Klammern gesteuert werden.Precedence and associativity can be controlled using parentheses. In x + y * z wird beispielsweise zuerst y mit z multipliziert und dann das Ergebnis zu x addiert, aber in (x + y) * z werden zunächst x und y addiert, und dann wird das Ergebnis mit z multipliziert.For example, x + y * z first multiplies y by z and then adds the result to x, but (x + y) * z first adds x and y and then multiplies the result by z.

Die meisten Operatoren können überladen werden.Most operators can be overloaded. Das Überladen von Operatoren ermöglicht die Angabe benutzerdefinierter Operatorimplementierungen für Vorgänge, in denen einer der Operanden oder beide einer benutzerdefinierten Klasse oder einem benutzerdefinierten Strukturtyp angehören.Operator overloading permits user-defined operator implementations to be specified for operations where one or both of the operands are of a user-defined class or struct type.

In der folgenden Übersicht der C#-Operatoren werden die Operatorkategorien gemäß der Rangfolge von oben nach unten aufgelistet.The following summarizes C#’s operators, listing the operator categories in order of precedence from highest to lowest. Operatoren der gleichen Kategorie haben den gleichen Rang.Operators in the same category have equal precedence. Jede Kategorie enthält eine Liste von Ausdrücken mit der Beschreibung des jeweiligen Ausdruckstyps.Under each category is a list of expressions in that category along with the description of that expression type.

  • PrimärPrimary
    • x.m: Memberzugriffx.m: Member access
    • x(...): Methoden- und Delegataufrufx(...): Method and delegate invocation
    • x[...]: Array- und Indexerzugriffx[...]: Array and indexer access
    • x++: Postinkrementx++: Post-increment
    • x--: Postdekrementx--: Post-decrement
    • new T(...): Objekt- und Delegaterstellungnew T(...): Object and delegate creation
    • new T(...){...}: Objekterstellung mit Initialisierernew T(...){...}: Object creation with initializer
    • new {...}: Anonymer Objektinitialisierernew {...}: Anonymous object initializer
    • new T[...]: Arrayerstellungnew T[...]: Array creation
    • typeof(T): Abrufen von Type Objekt für Ttypeof(T): Obtain Type object for T
    • checked(x): Auswerten von Ausdrücken in geprüftem Kontextchecked(x): Evaluate expression in checked context
    • unchecked(x): Auswerten von Ausdrücken in nicht geprüftem Kontextunchecked(x): Evaluate expression in unchecked context
    • default(T): Abrufen des Standardwerts von Typ Tdefault(T): Obtain default value of type T
    • delegate {...}: Anonyme Funktion (anonyme Methode)delegate {...}: Anonymous function (anonymous method)
  • UnärUnary
    • +x: Identität+x: Identity
    • -x: Negation-x: Negation
    • !x: Logische Negation!x: Logical negation
    • ~x: Bitweise Negation~x: Bitwise negation
    • ++x: Präinkrement++x: Pre-increment
    • --x: Prädekrement--x: Pre-decrement
    • (T)x: Explizites Konvertieren von x in den Typ T(T)x: Explicitly convert x to type T
    • await x: Asynchrones Warten auf den Abschluss von xawait x: Asynchronously wait for x to complete
  • MultiplikativMultiplicative
    • x * y: Multiplikationx * y: Multiplication
    • x / y: Divisionx / y: Division
    • x % y: Restx % y: Remainder
  • AdditivAdditive
    • x + y: Addition, Zeichenfolgenverkettung, Delegatkombinationx + y: Addition, string concatenation, delegate combination
    • x – y: Subtraktion, Delegatentfernungx – y: Subtraction, delegate removal
  • ShiftShift
    • x << y: Linksverschiebungx << y: Shift left
    • x >> y: Rechtsverschiebungx >> y: Shift right
  • Relational und TyptestRelational and type testing
    • x < y: Kleiner alsx < y: Less than
    • x > y: Größer alsx > y: Greater than
    • x <= y: Kleiner oder gleichx <= y: Less than or equal
    • x >= y: Größer oder gleichx >= y: Greater than or equal
    • x is T: true zurückgeben, wenn x ein T ist, andernfalls falsex is T: Return true if x is a T, false otherwise
    • x as T: x als T typisiert zurückgeben, oder null, wenn x kein T istx as T: Return x typed as T, or null if x is not a T
  • GleichheitEquality
    • x == y: Gleichx == y: Equal
    • x != y: Ungleichx != y: Not equal
  • Logisches ANDLogical AND
    • x & y: Ganzzahliges bitweises AND, boolesches logisches ANDx & y: Integer bitwise AND, boolean logical AND
  • Logisches XORLogical XOR
    • x ^ y: Ganzzahliges bitweises XOR, boolesches logisches XORx ^ y: Integer bitwise XOR, boolean logical XOR
  • Logisches ORLogical OR
    • x | y: Ganzzahliges bitweises OR, boolesches logisches ORx | y: Integer bitwise OR, boolean logical OR
  • Bedingtes ANDConditional AND
    • x && y: Wertet y nur aus, wenn x nicht false istx && y: Evaluates y only if x is not false
  • Bedingtes ORConditional OR
    • x || y: Wertet y nur aus, wenn x nicht true istx || y: Evaluates y only if x is not true
  • NULL-SammeloperatorNull coalescing
    • x ?? y: Wertet y aus, wenn x NULL ist, andernfalls xx ?? y: Evaluates to y if x is null, to x otherwise
  • BedingtConditional
    • x ? y : z: Wertet y aus, wenn x true ist, z, wenn x false istx ? y : z: Evaluates y if x is true, z if x is false
  • Zuweisung oder anonyme FunktionAssignment or anonymous function
    • x = y: Zuweisungx = y: Assignment
    • x op= y: Zusammengesetzte Zuweisung; unterstützte Operatoren sindx op= y: Compound assignment; supported operators are
      • *= /= %= += -= <<= >>= &= ^= |=*= /= %= += -= <<= >>= &= ^= |=
    • (T x) => y: Anonyme Funktion (Lambdaausdruck)(T x) => y: Anonymous function (lambda expression)