Implicit Conversion Operators for Value Types in C#

Question

I’ve come across this blog article: Implicit Conversion Operators are Bad. The article discourages the use of implicit conversion with reference types. The article describes problems caused by implicit conversions of reference types, which boils down to the following

[...] main question of this post: why are implicit conversion operators bad on reference types? [...] By adding an implicit conversion operator to a reference type, you have now introduced value semantics to assignments – but only from one type to another.
[emphasis original]

My question, however, is about value types. In the beginning, the article has got this statement:

Implicit conversion operators are incredibly important to the language, but only for value types.
[emphasis original]

The article doesn’t go into details on how to use implicit conversion with value types. That is what I’m wondering about. Here's my present thinking:

• The conversion operator is on a value type, and it returns a value type. Implicit - okay.
• The conversion operator is on a reference type, and it returns a value type. Implicit – okay.
• The conversion operator is on a value type, and it returns a reference type. (That would be a somewhat bizarre, but would it be wrong?) Implicit – not okay.
• The conversion operator is on a reference type, and it returns a reference type. Implicit – not okay.

In a more compact form:

• If it returns a value type, an implicit conversion operator is okay on both value type and reference type.
• If it returns a reference type, implicit conversion is not okay.

Is this correct? Is this complete?

p.s. For the most part, I work mostly with C and C++, where I have fine control over things like const, pointers, references. Of course, that comes at a risk of contracting nasty pointer-related bugs.

Answer 1

The short answer is that implicit operators are mostly about math.

All other things being equal, method calls are easier to read, easier to maintain, and easier to reason about, for non-math operations. Operators work with math because they are well understood; everyone knows what an addition operation is and what operator represents it. And when it's not being used in a math context (i.e. string concatenation), it still makes perfect sense semantically.

In the absence of math operations (i.e. reference types), operators work best when they are part of the language proper. The Lambda Expression operator in C# => is part of the language specification, is well-understood, and covers a broad variety of use cases. But it doesn't mean the same thing in other languages, like the + operator usually does.

Answer 2

If you stick to immutable reference types, they have the same value semantics as value types, and the restrictions disappear. I have never used conversion operators for mutable reference types, as I only use them in cases where value semantics makes more sense.