18

I have a type that represents a type of number. In this case, I'm working with megawatts, so I have created a type called Megawatt. I'd like to be able to work with these megawatts like I would an Int, Double, or any type of c# number type. Is this possible? If so, how do I do it?

Example:

public class Megawatt{
    public double Value { get; set; }
}

I want to be able to do this:

var startOfDay = new Megawatts{value=100};
var endOfDay = new Megawatts{value=65};
Megawatt result = startOfDay - endOfDay;

This is possible with DateTime... you can subtract one DateTime from another and get a TimeSpan. I'm hoping to do something similar.

Byron Sommardahl
  • 12,743
  • 15
  • 74
  • 131

5 Answers5

35

In addition to the good answers posted so far: you should make your type an immutable struct rather than a mutable value type. This is precisely the sort of job that immutable value types were designed for.

struct Megawatt
{
    private double Value { get; private set; }
    public Megawatt(double value) : this()
    {
        this.Value = value;
    }
    public static Megawatt operator +(Megawatt x, Megawatt y)
    {
        return new Megawatt(x.Value + y.Value);
    }
    public static Megawatt operator -(Megawatt x, Megawatt y)
    {
        return new Megawatt(x.Value - y.Value);
    }
    // unary minus
    public static Megawatt operator -(Megawatt x)
    {
        return new Megawatt(-x.Value);
    }
    public static Megawatt operator *(Megawatt x, double y)
    {
        return new Megawatt(x.Value * y);
    }
    public static Megawatt operator *(double x, Megawatt y)
    {
        return new Megawatt(x * y.Value);
    }
}

And so on. Note that you can add together two megawatts, but you cannot multiply two megawatts; you can only multiply megawatts by doubles.

You could also add more unit-laden types. For example, you could create a type MegawattHour and a type Hour and then say that Megawatt times Hour gives MegawattHour. You could also say that there is another type Joule, and there is an implicit conversion from MegawattHour to Joule.

There are a number of programming languages that support these sorts of operations with less verbosity than C#; if you do a lot of this sort of thing you might look into F#.

Eric Lippert
  • 647,829
  • 179
  • 1,238
  • 2,067
  • 1
    I'm a bit curious on this, why would we want the Megawatt type to be immutable ? – Julien May 01 '12 at 19:06
  • 8
    @Julien: You always want *values* to be immutable. Consider a reactor; it has a property "output". The output can change, obviously. Suppose you have two reactors and the output of both is 12 megawatts. To change reactor one's output to 13, you change *the output* of reactor one to 13. You don't say "hey 12, the value of 12 is now 13", because that would change the value of the outputs of *both* reactors. – Eric Lippert May 01 '12 at 20:08
  • Right. I also notice that your Megawatt is a struct which makes more sense than a class for this usage... Do you know something about the overhead when using this kind of structs rather than just a double ? – Julien May 02 '12 at 12:35
  • @Julien: What sort of "overhead" are you worried about? The memory overhead of a struct that contains one double is zero; the struct takes up exactly as much memory, per instance, as the double alone would. But there is more overhead involved in, say, doing the arithmetic because the jitter might not choose to inline the addition, as it does with double addition. – Eric Lippert May 02 '12 at 13:38
11

you should write your own operator overloading :

sample : 

   public static Megawatt operator +(Megawatt c1, Megawatt c2) 
   {
      return new Megawatt(c1.value+ c2.value);
   }
Royi Namir
  • 144,742
  • 138
  • 468
  • 792
2

This is called operator overloading. I suggest you read this article:

http://msdn.microsoft.com/en-us/library/aa288467(v=vs.71).aspx

It is a tutorial on the process. Basically you change the meaning of the - operator for those types.

As an example (stolen from the link)

public static Megawatt operator -(Megawatt c1, Megawatt c2) 
{
  // do whatever you want here
}

And this way your minus sign can now subtract MegaWatts

You can do this for any type or combination of types. You can even return yet a third type if you wanted to. Many languages support this concept and its quite useful.

devshorts
  • 8,572
  • 4
  • 50
  • 73
1

Expanded Answer: Operator overloading is the way to go in this case for sure. Overloading operators is a great option in C# that allows convenience of operators in lieu of methods in a class.

When you overload an operator such as + the corresponding compound assignment operator is also overloaded e.g. +=

As you would imagine with their use, operator overloads must be static and use the keyword operator as in @RoyiNamir's answer.

Just to expand on the answer the following binary comparison operators, in addition to mathematical operators, can be overloaded in pairs only:

  1. == and !=
  2. > and <
  3. >= and <=

As far as code design recommendation, just like @RoyiNamir said, the operator overloads should exist inside the class that they are overloading the operators of.

David Sulpy
  • 2,277
  • 2
  • 19
  • 22
0

Creating your own types is a good idea; it prevents Mars lander problems where you add kilograms and pounds. However, I suggest making them structs, not classes, as that will make them immutable and remove the potential of initializing null values. Also, make value private so you can do things like:

var startOfDay = new Megawatts(100);
var endOfDay = new Megawatts(65);
Megawatt result = startOfDay - endOfDay;

You should also consider implementing IComparable<>, IEquatable<>, conversion operators, and so on. This will let you perform comparisons on, and construct collections of, Megawatts.

Doing all of these is a lot of work; consult C# Canonical Forms.

Dour High Arch
  • 21,513
  • 29
  • 75
  • 90
  • ”I suggest making them structs, not classes, as that will make them immutable”: this implies that structs are necessarily immutable, and that is not true. – phoog May 06 '12 at 06:18