Implicit Operators in C#: How To Simplify Type Conversions
Tags: csharp, coding, programming, tutorial
Published: 2024-03-12 16:00:00

The post [Implicit Operators in C#: How To Simplify Type Conversions](https://www.devleader.ca/2024/03/04/implicit-operators-in-c-how-to-simplify-type-conversions/) appeared first on [Dev Leader](https://www.devleader.ca).

Implicit operators in C# allow us to define custom type conversions that happen — you guessed it — implicitly when working with multiple types. Implicitly in this case means that we don’t have to explicitly cast the types since the implicit operators we implement handle this for us.

[Implicit operators in C# play a role in simplifying data type conversions](https://www.devleader.ca/2023/08/04/implicit-operators-clean-code-secrets-or-buggy-nightmare/). They enable you to convert one type to another seamlessly without explicitly casting the values. This feature can save you time and effort and improve readability of code, but like all things we look at, there are cons to consider as well.

Throughout this article, we’ll [explore use cases for implicit operators in C#](https://www.devleader.ca/2023/05/31/implicit-operators-in-c-and-how-to-create-a-multi-type/) and examine code examples to illustrate their practical application. Let’s dive right in and learn all about implicit operators in C#!

---

## What are Implicit Operators in CSharp?

Implicit operators in C# are a powerful feature that allows objects of one type to be automatically converted to another type without the need for an explicit cast. They provide a way to seamlessly convert between types, making code more concise and readable.

Implicit operators are defined as special methods within a class or struct, using the `implicit` keyword. These methods specify the conversion from one type to another. When the compiler encounters an assignment or expression involving compatible types, it will automatically invoke the appropriate implicit operator to perform the conversion.

Here’s an example to illustrate the concept:

```csharp
public struct Celsius
{
    public Celsius(double value)
    {
        Value = value;
    }

    public double Value { get; }

    // Define an implicit operator from Celsius to Fahrenheit
    public static implicit operator Fahrenheit(Celsius celsius)
    {
        double fahrenheit = celsius.Value * 9d / 5d + 32d;
        return new Fahrenheit(fahrenheit);
    }
}

public struct Fahrenheit
{
    public Fahrenheit(double value)
    {
        Value = value;
    }

    public double Value { get; }
}

public class Program
{
    public static void Main()
    {
        // Implicitly convert a Celsius temperature to Fahrenheit
        Celsius celsius = new Celsius(25);
        Fahrenheit fahrenheit = celsius;

        Console.WriteLine(fahrenheit.Value);  // Output: 77
    }
}
```

In this example, we have a `Celsius` type with a `Value` property. We define an implicit operator in the `Celsius` type that converts a `Celsius` value to `Fahrenheit`. When we assign a `Celsius` value to a `Fahrenheit` variable, the compiler automatically invokes the implicit operator, converting the temperature from Celsius to Fahrenheit.

Implicit operators in C# can greatly simplify code by allowing objects to be converted implicitly when appropriate. This can make code more readable and reduce the need for explicit type conversions. However, it’s important to use implicit operators with caution and ensure that the conversion is safe and logical. Check out [this video on using Implicit Operators in C#](https://youtu.be/tgPTQ-ST8qQ) [for more information:](https://youtu.be/tgPTQ-ST8qQ)

{% embed https://youtu.be/tgPTQ-ST8qQ %}

---

## Pros and Cons of Implicit Operators in CSharp

Like everything we look at, there are going to be pros and cons. I try to make sure that every topic we cover together on both my site and [my YouTube channel](https://www.youtube.com/@devleader?sub_confirmation=1) looks at multiple perspectives. In my opinion, this is the best way to understand when things are a better or worse fit.

### Pros of Implicit Operators in CSharp

Implicit operators in C# provide several benefits in software development. They can simplify code and improve readability by allowing automatic type conversions without requiring explicit casting or conversion methods. This eliminates the need for repetitive and potentially error-prone code, making the codebase more concise and easier to understand.

Consider the following example where we have a custom type, `Length`, representing a unit of measurement that we’re working with:

```csharp
public struct Length
{
    public double Value { get; set; }

    // Implicit conversion from Length to double
    public static implicit operator double(Length length)
    {
        return length.Value;
    }
}
```

With the implicit operators defined, we can use this custom type in calculations without explicitly converting them to their underlying types:

```csharp
Length length = new Length { Value = 5.0 };
double finalResult = (length * 1.23) / 42d;
Console.WriteLine($"The answer is {finalResult}.");
```

An important note here is that probably any quantity that has a value like this would need to indicate the unit of measurement — this is omitted in this example just because you could do this in a number of ways and I don’t want that to be the focus. So there’s an assumption in this example that we DO know what unit we’re working with here.

The implicit conversion thanks to the operator that we added simplifies the code by reducing the number of explicit conversions and improves readability by expressing the intent more clearly. If we had to litter mathematical statements with (double) and other casts throughout it, it starts to detract from the understanding of the expression itself.

### Cons of Implicit Operators in CSharp

One of the big cons of implicit operators is very much related to one of the pros that we looked at. The fact that we CAN implicitly convert can lend itself to very odd situations if we’re not careful about what we implicitly convert to.

Let’s introduce another custom type that can also be cast to a double. We can make a similar assumption as before that we know the units of this quantity-representing type. Here’s the code, very much like the previous type:

```csharp
public struct Temperature
{
    public double Value { get; set; }

    // Implicit conversion from Temperature to double
    public static implicit operator double(Temperature temperature)
    {
        return temperature.Value;
    }
}
```

Because both types are convertible to double implicitly, we have the power to write mathematical expressions like this without casting — but should we?

```csharp
Length length = new Length { Value = 5.0 };
Temperature temperature = new Temperature { Value = 25.0 };
double finalResult = ((length * temperature) + 42d) / 1.23;
Console.WriteLine($"The answer is {finalResult}.");
```

In this example, the implicit operators allow the multiplication between `Length` and `Temperature` objects to be performed directly, without the need for explicit conversions. In isolation, it may have made more sense to allow for either type to be convertible to double, but when they both can be, the results may be unexpected.

To elaborate, with an example where in isolation if your length was meters, casting them to a double called lengthInMeters isn’t too much of a stretch. But double itself is unitless, and when we start compounding this by mixing in other types, the burden of tracking what unit we’re \*actually\* talking about starts outweighing the benefit of the implicit conversion. In my opinion, it would be much more readable if we were forced to explicitly cast and track the conversions in intermediate steps if necessary.

This is of course one example, but the point is that if you are doing implicit conversions where you potentially lose data resolution (in this case, units), then you’re at risk of this sort of thing. Nothing prevents us as C# developers from doing this — except maybe other developers on pull requests and code reviews!

{% embed https://weekly.devleader.ca/embed %}

---

## Use Cases for Implicit Operators

In this section, I’ll present three practical use cases for implicit operators in C#. Implicit operators are a powerful feature that allow for automatic conversion between different types. Understanding and utilizing implicit operators can greatly simplify your code and improve its readability. Let’s explore three use cases where implicit operators can be useful in C#.

### Converting Custom Types – Money on My Mind

One of the primary use cases for implicit operators is converting custom types. Suppose we have a custom type `Money`, which represents a some amount of currency. We may want to allow implicit conversion from `Money` to `double` to simplify calculations and enable direct comparisons. Here’s how we can define an implicit operator to achieve this:

```csharp
public struct Money
{
    private readonly double _amount;

    public Money(double amount)
    {
        _amount = amount;
    }

    public double Amount => _amount;

    // Implicitly converts Money to double
    public static implicit operator double(Money money)
    {
        return money._amount;
    }

    // Implicitly converts double to Money
    public static implicit operator Money(double amount)
    {
        return new Money(amount);
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        Money moneyInWallet = new Money(100.50); // $100.50
        double cash = moneyInWallet; // Implicit conversion to double
        
        // Adding more money
        moneyInWallet += 99.50; // Implicit conversion from double to Money, then addition

        Console.WriteLine(cash); // Output: 100.5
        Console.WriteLine(moneyInWallet.Amount); // Output: 200
    }
}
```

By defining an implicit conversion operator from `Money` to `double`, we can now directly assign a `Money` object to a `double` variable without the need for explicit type casting. If you wanted to have financial calculations that were more expressive by having a `Money` type, this could be useful without forcing casting operations everywhere.

### Simplifying Math Operations

Implicit operators can also simplify math operations by automatically converting operands to compatible types. Let’s say we have a type `ComplexNumber` representing complex numbers, and we want to perform arithmetic operations on them. By using implicit operators, we can seamlessly convert integers and doubles to `ComplexNumber` when performing mathematical operations. In this case, we’ll not only need implicit operators for converting, but we’ll need an operator for doing arithmetic between two `ComplexNumber` instances.

Here’s an example:

```csharp
public class ComplexNumber
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public ComplexNumber(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // Implicitly converts int to ComplexNumber
    public static implicit operator ComplexNumber(int number)
    {
        return new ComplexNumber(number, 0);
    }

    // Implicitly converts double to ComplexNumber
    public static implicit operator ComplexNumber(double number)
    {
        return new ComplexNumber(number, 0);
    }

    // Adds two ComplexNumber instances
    public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b)
    {
        return new ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }
}

// Usage
ComplexNumber complexNumber = 2.5; // Implicit conversion from double
complexNumber += 3; // Implicit conversion from int
Console.WriteLine(complexNumber.Real); // Output: 5.5
```

With implicit operators, we can perform mathematical operations on `ComplexNumber` objects using integers or doubles without explicit conversions. If you were creating an application where there was a lot of arithmetic with these concepts, you may find that it improves the readability of your code to not have to routinely cast.

### Conversions with Other Libraries: A Geometry Example

Implicit operators can be particularly useful when working with libraries or APIs that have different types representing similar concepts. By creating implicit operators between these types, you can seamlessly convert between them and simplify interactions with the library.

For example, consider a library we’d like to create that provides different types for representing points in 2D space. The library may define `Point2D` and `Vector2D` types, each with its own set of operations. By defining implicit operators between these types, you make it easier for users to work with these objects interchangeably, depending on the context:

```csharp
public struct Point2D
{
    // Implicit conversion from Point2D to Vector2D
    public static implicit operator Vector2D(Point2D point)
    {
        return new Vector2D(point.X, point.Y);
    }
}

public struct Vector2D
{
    // Implicit conversion from Vector2D to Point2D
    public static implicit operator Point2D(Vector2D vector)
    {
        return new Point2D(vector.X, vector.Y);
    }
}
```

With these implicit operators in place, users can seamlessly convert between `Point2D` and `Vector2D` objects, depending on the needs of their code:

```csharp
Point2D point = new Point2D(2, 3);
Vector2D vector = new Vector2D(4, 5);

// Implicit conversion from Point2D to Vector2D
Vector2D convertedVector = point;

// Implicit conversion from Vector2D to Point2D
Point2D convertedPoint = vector;
```

In this scenario, implicit operators simplify the code and make it more expressive by allowing users to work with the same underlying data with different objects representing different concepts. There may be benefits in similar situations where we’re incorporating a third-party library into our code base, and want to offer a level of flexibility when interacting with it. For the types that we own, we could provide implicit conversions to the library in question, and it may simplify logic within our codebase when interacting with the library.

---

## Wrapping Up Implicit Operators in CSharp

In this article, we explored implicit operators in C#, and how they can simplify code and improve code readability. Implicit operators allow for automatic conversions between different types, making it easier to work with data and objects in C#.

My personal opinion on implicit operators in C# is that type conversion is easy to “get wrong”. If you’re not sure what you’re doing, I think it’s an easy thing that you could mess up and create more complications in your code than it’s worth getting potential readability out of it. However, if you’re creating code that has an emphasis on working between several types as the core of what you’re doing, you may have better insights into effective ways to use these properly.

If you found this useful and you’re looking for more learning opportunities, consider [subscribing to my free weekly software engineering newsletter](https://subscribe.devleader.ca) and check out my [free videos on YouTube](https://www.youtube.com/@devleader?sub_confirmation=1)!

{% embed https://weekly.devleader.ca/embed %}

---

## **Want More Dev Leader Content?**

* Follow along on this platform if you haven’t already!    
* Subscribe to my free weekly software engineering and dotnet-focused newsletter. I include exclusive articles and early access to videos:  
    [**SUBSCRIBE FOR FREE**](https://subscribe.devleader.ca/)    
* Looking for courses? Check out my offerings:  
    [**VIEW COURSES**](https://devleader.ca/courses)    
* E-Books & other resources:  
    [**VIEW RESOURCES**](https://products.devleader.ca/)    
* Watch hundreds of full-length videos on my YouTube channel:  
    [**VISIT CHANNEL**](https://youtube.com/@devleader?sub_confirmation=1)    
* Visit my website for hundreds of articles on various software engineering topics (including code snippets):  
    [**VISIT WEBSITE**](https://devleader.ca/)    
* Check out the repository with many code examples from my articles and videos on GitHub:  
    [**VIEW REPOSITORY**](https://github.com/ncosentino/DevLeader)