Überladbare Operatoren (C#-Programmierhandbuch)Overloadable Operators (C# Programming Guide)

C# ermöglicht benutzerdefinierten Typen, mithilfe des Schlüsselworts operator Operatoren durch das Definieren von statischen Memberfunktionen zu überladen.C# allows user-defined types to overload operators by defining static member functions using the operator keyword. Nicht alle Operatoren können überladen werden und weisen andere Einschränkungen auf. Eine entsprechende Auflistung finden Sie in dieser Tabelle:Not all operators can be overloaded, however, and others have restrictions, as listed in this table:

OperatorenOperators ÜberladbarkeitOverloadability
+, -, !, ~, ++, --, true, false+, -, !, ~, ++, --, true, false Diese unären Operatoren können überladen werden.These unary operators can be overloaded.
+, -, *, /, %, &, |, ^, <<, >>+, -, *, /, %, &, |, ^, <<, >> Diese binären Operatoren können überladen werden.These binary operators can be overloaded.
==, !=, <, >, <=, >===, !=, <, >, <=, >= Die Vergleichsoperatoren können überladen (beachten Sie jeden Hinweis im Anschluss an diese Tabelle) werden.The comparison operators can be overloaded (but see the note that follows this table).
&&, ||&&, || Die bedingten logischen Operatoren können nicht überladen werden. Sie werden jedoch mithilfe von & und | ausgewertet, die überladen werden können.The conditional logical operators cannot be overloaded, but they are evaluated using & and |, which can be overloaded.
[][] Der Arrayindizierungsoperator kann nicht überladen werden. Sie können jedoch Indexer definieren.The array indexing operator cannot be overloaded, but you can define indexers.
(T)x(T)x Der Umwandlungsoperator kann nicht überladen werden. Sie können jedoch neue Konvertierungsoperatoren definieren (siehe explicit und implicit).The cast operator cannot be overloaded, but you can define new conversion operators (see explicit and implicit).
+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= Zuweisungsoperatoren können nicht überladen werden. += wird jedoch beispielsweise mithilfe von + ausgewertet, was wiederum überladen werden kann.Assignment operators cannot be overloaded, but +=, for example, is evaluated using +, which can be overloaded.
=, ., ?:, ??, ->, =>, f(x), as, checked, unchecked, default, delegate, is, new, sizeof, typeof=, ., ?:, ??, ->, =>, f(x), as, checked, unchecked, default, delegate, is, new, sizeof, typeof Diese Operatoren können nicht überladen werden.These operators cannot be overloaded.

Hinweis

Die Vergleichsoperatoren müssen, sofern sie überladen sind, paarweise überladen werden. Beim Überladen von == muss != demnach ebenfalls überladen werden.The comparison operators, if overloaded, must be overloaded in pairs; that is, if == is overloaded, != must also be overloaded. Das Gegenteil trifft ebenfalls zu, wenn das Überladen von != eine Überladung von == erfordert.The reverse is also true, where overloading != requires an overload for ==. Das gleiche gilt für die Vergleichsoperatoren <, >, <= und >=.The same is true for comparison operators < and > and for <= and >=.

Für das Überladen eines Operators in einer benutzerdefinierten Klasse muss eine Methode in der Klasse mit der richtigen Signatur erstellt werden.To overload an operator on a custom class requires creating a method on the class with the correct signature. Die Methode muss als „operator X“ bezeichnet werden, wobei X für den Namen oder das Symbol des zu überladenden Operators steht.The method must be named "operator X" where X is the name or symbol of the operator being overloaded. Unäre Operatoren verfügen über einen Parameter. Demgegenüber weisen binäre Operatoren zwei Parameter auf.Unary operators have one parameter, and binary operators have two parameters. In jedem Fall muss ein Parameter denselben Typ wie die Klasse oder Struktur aufweisen, die den Operator deklariert.In each case, one parameter must be the same type as the class or struct that declares the operator.

public static Complex operator +(Complex c1, Complex c2)
{
    return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}

Es ist üblich, Definitionen zu verwenden, die umgehend das Ergebnis des Ausdrucks zurückgeben.It is common to have definitions that simply return immediately with the result of an expression. Es gibt eine Syntaxabkürzung mithilfe von => für diese SituationenThere is a syntax shortcut using => for these situations.

public static Complex operator +(Complex c1, Complex c2) =>
        new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);

// Override ToString() to display a complex number in the traditional format:
public override string ToString() => $"{this.real} + {this.imaginary}";

Weitere Informationen finden Sie unter Vorgehensweise: Verwenden der Operatorüberladung zum Erstellen einer Klasse für komplexe Zahlen.For more information, see How to: Use Operator Overloading to Create a Complex Number Class.

Siehe auchSee also

C#-ProgrammierhandbuchC# Programming Guide
Anweisungen, Ausdrücke und OperatorenStatements, Expressions, and Operators
OperatorenOperators
C#-OperatorenC# Operators
Why are overloaded operators always static in C#? (Warum sind überladene Operatoren in C# immer statisch?)Why are overloaded operators always static in C#?