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 >=, true i false
  • 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ć metody Equals i GetHashCode, w przeciwnym wypadku kompilator zgłosi ostrzeżenie.
  • Warto też implementować interfejsy IEquatable<T> i IComparable<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 used

Jeż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.3

Operatory 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);   // OverflowException

Definiowanie 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