When should I use C#'s implicit type conversion operator?

Question

In C#, we can overload the implicit conversion operator like this (example from MSDN):

struct Digit
{
    /* ... */
    public static implicit operator byte(Digit d)  // implicit digit to byte conversion operator
    {
        /* ... */
    }
}

Thus, we can have a type, a custom value type, magically converting itself to another (unrelated) type, leaving the audience in bewilderment (until they peer into the backstage and see the implicit conversion operator, that is).

I don't like leaving anyone who reads my code in bewilderment. I don't think many people do.

The question is, what are the use-cases of the implicit type conversion operator which won't render my code much more difficult to understand?

Answer 1

I would only recommend implicit conversions between types that roughly represent the same values in different ways. For instance:

• Different color types like RGB, HSL, HSV and CMYK.
• Different units for the same physical quantity (Meter vs Inch).
• Different coordinate systems (polar vs Cartesian).

However, there are some strong guidelines that indicate when it is not appropriate to define an implicit conversion:

• If the conversion causes a significant loss of precision or range, then it shouldn't be implicit (e.g.: from float64 to float32 or from long to int).
• If the conversion can throw an (InvalidCast) exception, then it shouldn't be implicit.
• If the conversion causes a heap allocation each time it is performed, then it shouldn't be implicit.
• If the conversion is not an O(1) operation, then it shouldn't be implicit.
• If the source type or the target type is mutable, then the conversion shouldn't be implicit.
• If the conversion is dependent on some sort of context (database, culture settings, configuration, file system, etc.) then it shouldn't be implicit (I would also discourage an explicit conversion operator in this case).

Now say your conversion operator f: T1 -> T2 doesn't violate any of the rules above, then the following behavior strongly indicates that the conversion can be implicit:

• If a == b then f(a) == f(b).
• If a != b then f(a) != f(b).
• If a.ToString() == b.ToString() then f(a).ToString() == f(b).ToString().
• Etc. for other operations that are defined on both T1 and T2.

Answer 2

The question is, what are the use-cases of the implicit type conversion operator which won't render my code much more difficult to understand?

When the types aren't unrelated (to programmers). There are (rare) scenarios where you have two unrelated types (as far as the code is concerned), that are actually related (as far as the domain or reasonable programmers) are concerned.

For example, some code to do string matching. A common scenario is to match a string literal. Rather than calling IsMatch(input, new Literal("some string")), an implicit conversion lets you get rid of that ceremony - the noise in the code - and focus on the string literal.

Most any programmer will see IsMatch(input, "some string") and quickly intuit what is going on. It makes your code clearer at the call site. In short, it makes it a bit easier to understand what is going on, at a slight expense of how that is going on.

Now, you might argue that a simple function overload to do the same thing would be better. And it is. But if this sort of thing is ubiquitous, then having one conversion is cleaner (less code, increased consistency) than doing a pile of function overloads.

And you might argue that it is better to require programmers to explicitly create the intermediate type so they see "what is really going on". That is less straightforward. Personally, I think that the literal string match example is very clear about "what is really going on" - the programmer needs not know the mechanics of how everything happens. Do you know how all your code is executed by the various processors your code runs on? There is always a line of abstraction where programmers stop caring about how something works. If you think that the implicit conversion steps are important, then don't use the implicit conversion. If you think they're just ceremony to keep the computer happy, and the programmer would be better off not seeing that noise everywhere, then consider it.