Przeciążanie operatorów#
C# wspiera przeciążanie operatorów. Operatory pozwalają na bardziej zwięzły zapis operacji. Nie powinno się ich nadużywać - stosujemy je głównie wtedy, gdy jest to intuicyjne i nie budzi wątpliwości, np. dla własnych typów numerycznych. Operator powinien robić to, czego byśmy się spodziewali.
Przykład#
Operatory są definiowane jako publiczne, statyczne składowe typu. Nazwą metody musi być symbol operacji poprzedzony słowem kluczowym operator. W zależności od operacji metoda przyjmuje jeden lub dwa parametry.
public struct Complex
{
public double Real { get; }
public double Imaginary { get; }
public Complex(double real, double imaginary)
{
Real = real;
Imaginary = imaginary;
}
public static Complex operator +(Complex a, Complex b)
{
return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
}
public static Complex operator -(Complex a, Complex b)
{
return new Complex(a.Real - b.Real, a.Imaginary - b.Imaginary);
}
public static Complex operator -(Complex a)
{
return new Complex(-a.Real, -a.Imaginary);
}
public static Complex operator *(Complex a, Complex b)
{
return new Complex(
a.Real * b.Real - a.Imaginary * b.Imaginary,
a.Real * b.Imaginary + a.Imaginary * b.Real
);
}
public static bool operator ==(Complex a, Complex b)
{
return a.Real == b.Real && a.Imaginary == b.Imaginary;
}
public static bool operator !=(Complex a, Complex b)
{
return !(a == b);
}
public override bool Equals(object? obj)
{
return obj is Complex complex && complex == this;
}
public override int GetHashCode()
{
return HashCode.Combine(Real, Imaginary);
}
}- Niektóre operatory muszą być implementowane parami:
==i!=,<i>,<=i>=,trueifalse - Operatory złożonego przypisania (np.
+=,/=) są niejawnie przeciążone przez przeciążenie odpowiadających im operatorów niezłożonych. Od C# 14 można je także definiować jawnie. - Podczas przeciążania operatora
==należy też nadpisać metodyEqualsiGetHashCode, w przeciwnym wypadku kompilator zgłosi ostrzeżenie. - Warto też implementować interfejsy
IEquatable<T>iIComparable<T>. W .NET 7 (C# 11) i nowszych, przy przeciążaniu operatorów arytmetycznych, warto rozważyć implementację interfejsów generycznych, np.IAdditionOperators<TSelf, TOther, TResult>,IMultiplyOperators<TSelf, TOther, TResult>, itp. Dzięki temu będziemy mogli potem ograniczać typ generyczny, a także jest to forma dokumentacji kodu.
Operatory przypisania złożonego (C# 14)#
Przed C# 14 wyrażenie x += y było zawsze obliczane jako x = x + y. Dla mutowalnych typów przechowujących dużo danych (np. wektorów czy macierzy) oznacza to alokację nowego obiektu i kopiowanie danych przy każdym +=. Od C# 14 typ może definiować operatory przypisania złożonego (+=, -=, *=, …) oraz operatory ++ i -- jako metody instancyjne, które modyfikują obiekt w miejscu. Taki operator musi być publiczny, nie może być statyczny i zwraca void; operator przypisania złożonego przyjmuje jeden parametr (prawą stronę przypisania), a ++ i -- nie przyjmują żadnego.
public class Vector
{
private readonly double[] _data;
public Vector(int size) => _data = new double[size];
public double this[int i]
{
get => _data[i];
set => _data[i] = value;
}
public static Vector operator +(Vector a, Vector b)
{
var result = new Vector(a._data.Length);
for (int i = 0; i < a._data.Length; i++)
result._data[i] = a._data[i] + b._data[i];
return result;
}
public void operator +=(Vector other)
{
for (int i = 0; i < _data.Length; i++)
_data[i] += other._data[i];
}
public void operator ++()
{
for (int i = 0; i < _data.Length; i++)
_data[i]++;
}
}var v = new Vector(3);
var w = new Vector(3);
w[0] = 1;
var sum = v + w; // static operator +: allocates a new Vector
v += w; // instance operator +=: modifies v in place
v++; // instance operator ++
Console.WriteLine($"{v[0]} {v[1]} {sum[0]}"); // 2 1 1
// var old = v++; // error: the instance ++ cannot be used when the result of x++ is usedJeżeli typ nie definiuje operatora przypisania złożonego, kompilator nadal oblicza x += y jako x = x + y. Instancyjny operator ++ nie jest używany, gdy wynik postfiksowego x++ jest wykorzystywany (np. y = x++), ponieważ potrzebna jest wartość sprzed inkrementacji - wtedy wymagany jest statyczny operator ++.
Od C# 14 operatory można deklarować także w blokach rozszerzeń (extension blocks), co pozwala dodawać operatory do typów, których nie kontrolujemy - zobacz Metody rozszerzające.
Dziedziczenie operatorów#
Operatory są składowymi statycznymi, więc nie są polimorficzne: nie mogą być wirtualne ani nadpisywane, a operator jest wybierany w czasie kompilacji na podstawie statycznych typów operandów (operator zadeklarowany w klasie bazowej działa także dla obiektów klas pochodnych). Od C# 11 operatory można deklarować w interfejsach jako static abstract lub static virtual - typy implementujące muszą (a w przypadku static virtual mogą) dostarczyć własną implementację, a operatora można używać poprzez parametr generyczny ograniczony tym interfejsem.
public interface IIncrementable<TSelf> where TSelf : IIncrementable<TSelf>
{
public static abstract TSelf operator ++(TSelf self);
}Matematyka generyczna (C# 11)#
Statyczne abstrakcyjne operatory w interfejsach są podstawą matematyki generycznej (generic math, .NET 7+). Wbudowane typy liczbowe implementują interfejsy generyczne, takie jak INumber<TSelf> (przestrzeń nazw System.Numerics), który udostępnia operatory arytmetyczne i porównania oraz składowe takie jak T.Zero i T.One. Dzięki temu jedna metoda generyczna może działać dla dowolnego typu liczbowego - w C++ zwykle realizuje się to szablonami:
using System.Numerics;
static T Sum<T>(IEnumerable<T> values) where T : INumber<T>
{
T result = T.Zero;
foreach (T value in values)
result += value;
return result;
}
Console.WriteLine(Sum([1, 2, 3])); // 6
Console.WriteLine(Sum([1.5, 2.5])); // 4
Console.WriteLine(Sum([0.1m, 0.2m])); // 0.3Operatory checked (C# 11)#
Od C# 11 typ może zdefiniować osobną wersję operatora dla kontekstu checked, np. rzucającą wyjątek OverflowException przy przepełnieniu. Można ją zadeklarować dla operatorów ++, --, jednoargumentowego -, dwuargumentowych +, -, *, / oraz dla jawnych konwersji. Zawsze wymaga ona zwykłej wersji tego samego operatora, która jest używana w kontekście unchecked (domyślnym):
public readonly struct Money(int cents)
{
public int Cents { get; } = cents;
public static Money operator +(Money a, Money b) => new(a.Cents + b.Cents);
public static Money operator checked +(Money a, Money b) => new(checked(a.Cents + b.Cents));
}var max = new Money(int.MaxValue);
var one = new Money(1);
Console.WriteLine(unchecked(max + one).Cents); // -2147483648
Console.WriteLine(checked(max + one).Cents); // OverflowExceptionDefiniowanie konwersji#
Można definiować własne konwersje dla typu, zarówno jawne, jak i niejawne.
- Niejawne (
implicit) konwersje powinny być zawsze bezpieczne, nie powodować utraty informacji i nie rzucać wyjątków. - Jawne (
explicit) konwersje mogą się nie powieść (np. rzucając wyjątek) lub mogą powodować utratę informacji - powinny wymagać od programisty świadomej decyzji (użycia rzutowania).
public struct Complex
{
public double Real { get; }
public double Imaginary { get; }
public Complex(double real, double imaginary)
{
Real = real;
Imaginary = imaginary;
}
public static implicit operator Complex(double d)
{
return new Complex(d, 0.0);
}
public static explicit operator double(Complex c)
{
return c.Real;
}
}Użycie:
Complex c = new Complex(3.0, 4.0);
double d = (double)c; // explicit conversion
c = 5.0; // implicit conversion