Educating about C# and F#

Explaining Implicit Conversion Operators in C#

Sometime ago at work, I discovered a class that could automatically convert to and from a string whenever it was needed. At first I was confused as to how that could occur.Then I looked through the class definition and encountered the implicit operator.

It wasn’t something I was familiar with, so I thought it was worth blogging about to let you know it exists as well.

Types in C#

C# is a strongly typed language. The compiler enforces proper uses of types.

If you have a method that takes type A, and you attempt to pass type B to it, compile error!!!

There are implicit conversions available for certain builtin types, like the following:

Num is an int, but it can be passed to a method that accepts a double. This kind of implicit conversion isn’t super radical to me.

Outside of these builtin types, I can’t remember ever encountering any other implicit conversions.

It turns out to be really easy to define an implicit conversion between any type that you need.


Lets say we had defined a class to hold file paths for us.

I wouldn’t suggest doing this in real life, definitely better to use the C# defined Path class, but it’s an example.

The FilePath class has an internal _path string variable to hold the path for us. Pretty simple.

Lets define a PathOps class that has some methods useful for dealing with paths.

One method takes a string and the other takes a FilePath. Not that cleanest API, but lets see what happens when we leverage implicit conversion.

Lets add two implicit operators to our class.

These implicit operators will automatically convert between a string and a FilePath whenever is needed.

So when we now call these methods, it doesn’t matter whether we use a string or a FilePath.

Whatever type the method requires, C# will convert to that type because of the implicit operators.


What’s the format for creating an implicit conversion? Quite simply the following:

«access specifier» static implicit operator «expected type» («current type» currentValue)

When C# has a FilePath but needs a string, it calls this method:

When it has a string but needs a FilePath, it calls the other method:

Pretty simple definition.


While this can be a useful feature, I would argue that being explicit is the better way to go in most circumstances.

Implicit conversions definitely have a cost to them. It could cause potentially subtle bugs or the wrong method to be called. I can’t personally think of a use case where implicit conversion saved me enough time to use it.

Just to let you know where I stand on this language feature.

Wrapping Up

Until recently, implicit conversion in C# wasn’t something I realized I had control over. It’s an interesting feature, but not something I plan on implementing soon.