Overloading assignment operator in C#

Question

I know the = operator can't be overloaded, but there must be a way to do what I want here:

I'm just creating classes to represent quantitative units, since I'm doing a bit of physics. Apparently I can't just inherit from a primitive, but I want my classes to behave exactly like primitives -- I just want them typed differently.

So I'd be able to go,

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

etc.

I'm not sure how to do this. I figured I'd just write some classes like so:

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

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

But apparently I can't overload the assignment operator. Is there any way I can get this behavior?

Answer 1

It sounds like you should be using a struct rather than a class... and then creating an implicit conversion operator, as well as various operators for addition etc.

Here's some sample 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;
    }
}

(As a side-note... I don't see how this really represents a velocity, as surely that needs a direction as well as a magnitude.)

Answer 2

You can create implicit conversion operators. There is a page on MSDN with a nice example.

It's also a good idea to make them immutable structs. That's exactly what the "primitives" are, and that's what makes it impossible to inherit from them. You want a struct because you want value-type semantics, instead of reference type semantics. And you want them immutable because mutable value types are generally a bad idea.

Answer 3

I think it cannot be overloaded because C# classes are all derived from Object, so they are basically objects, and when you use the assignment operators, you are basically just referencing another object. On the other hand, if you use a structure, then you basically need all the information, so when you use = operator, all fields will be copied.

So I would say, face it, and implement a function called Copy() and you should be fine :-)