web-dev-qa-db-fra.com

Opérateur d'affectation de surcharge en C #

Je connais le = L'opérateur ne peut pas être surchargé, mais il doit y avoir un moyen de faire ce que je veux ici:

Je crée juste des classes pour représenter des unités quantitatives, car je fais un peu de physique. Apparemment, je ne peux pas simplement hériter d'une primitive, mais je veux que mes classes se comportent exactement comme des primitives - je veux juste qu'elles soient typées différemment.

Je pourrais donc y aller,

Velocity ms = 0;
ms = 17.4;
ms += 9.8;

etc.

Je ne sais pas comment faire ça. J'ai pensé que j'écrirais juste des cours comme ça:

class Power
{
    private Double Value { get; set; }

    //operator overloads for +, -, /, *, =, etc
}

Mais apparemment, je ne peux pas surcharger l'opérateur d'affectation. Existe-t-il un moyen d'obtenir ce comportement?

c#operator-overloading
57
Carson Myers

Il semble que vous devriez utiliser un struct plutôt qu'une classe ... puis créer un opérateur de conversion implicite, ainsi que divers opérateurs pour l'ajout, etc.

Voici un exemple de code:

public struct Velocity
{
    private readonly double value;

    public Velocity(double value)
    {
        this.value = value;
    }

    public static implicit operator Velocity(double value)
    {
        return new Velocity(value);
    }

    public static Velocity operator +(Velocity first, Velocity second)
    {
        return new Velocity(first.value + second.value);
    }

    public static Velocity operator -(Velocity first, Velocity second)
    {
        return new Velocity(first.value - second.value);
    }

    // TODO: Overload == and !=, implement IEquatable<T>, override
    // Equals(object), GetHashCode and ToStrin
}

class Test
{
    static void Main()
    {
        Velocity ms = 0;
        ms = 17.4;
        // The statement below will perform a conversion of 9.8 to Velocity,
        // then call +(Velocity, Velocity)
        ms += 9.8;
    }
}

(En note ... Je ne vois pas comment cela représente vraiment une vitesse, car cela a sûrement besoin d'une direction ainsi que d'une amplitude.)

87
Jon Skeet

Vous pouvez créer des opérateurs de conversion implicites. Il y a un page sur MSDN avec un bel exemple.

C'est aussi une bonne idée de leur faire des structures immuables. C'est exactement ce que sont les "primitives", et c'est ce qui rend impossible d'en hériter. Vous voulez une structure parce que vous voulez une sémantique de type valeur, au lieu d'une sémantique de type référence. Et vous les voulez immuables, car les types de valeurs mutables sont généralement un mauvaise idée.

10
R. Martinho Fernandes