Type conversions with implicit and explicit operators

Introduction

In this article, I'm going to describe how to use type conversion operators (implicit and explicit) in user-defined classes. We commonly come across situations in which the same real-world entity is represented in two different classes. For example, when integrating two sub-systems into one, we see an entity is represented as Author in one sub-system and as Writer in the other. Although in the combined system both represents the same real-world object, it is difficult to represent them as one throughout because of the extensive code change and dependencies.

In these situations, normally when the objects move between systems, at one point, we have to convert the Author to Writer and vice-versa. Usually we go ahead and create helper classes or extension methods to convert one into the other. But in this article, I'm going to show you how we can use the implicit/explicit operators to make the conversions (Author to Writer or Writer to Author) more easy!

Background

Casting

Conversion between data types can be done in two ways by casting:

• Implicit casting
• Explicit casting

Implicit casting

Implicit casting doesn't require a casting operator. This casting is normally used when converting data from smaller integral types to larger or derived types to the base type.

int x = 123;
double y = x;

In the above statement, the conversion of data from int to double is done implicitly, in other words programmer don't need to specify any type operators.

Explicit casting

Explicit casting requires a casting operator. This casting is normally used when converting a double to int or a base type to a derived type.

double y = 123;
int x = (int)y;

In the above statement, we have to specify the type operator (int) when converting from double to int else the compiler will throw an error. You can learn more about casting here.

Conversion operators

Conversion operators help to cast user-defined types from one to the other much like the basic types. For implicit or explicit conversion, we have to create a static method in the corresponding class with method name as the type it returns including the keyword that says implicit or explicit. To know more, follow this link.

Let's see an example!

Let's see an example of how we can implement the casting mechanism in our user-defined classes using conversion operators.

public class Author
{
    public string First;
    public string Last;
    public string[] BooksArray;
}

public class Writer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public List<string> Books { get; set; }
}

We have two classes Author and Writer used in different sub-systems that represent the same real-world entity. Let's see how we can implement implicit or explicit casting in the classes.

Author author2 = (Author)writer; //explicit casting 
Author author1 = writer; //implicit casting

First, let's try explicit casting,

• Create a static method in the Author class. The name of the method should be the same as the type it's going to be casted; in our case, it is Writer. For explicit casting, we need the explicit keyword to be included in the method definition.

public static explicit operator Writer(Author a)
{
    //implementation goes here..
}

• Create an instance of the Writer class and populate its fields from the passed Author instance.

public static explicit operator Writer(Author a)
{
    return new Writer
    {
        FirstName = a.First,
        LastName = a.Last,
        Books = a.BooksArray != null ? a.BooksArray.ToList() : null
    };
}

That's it! Now wherever we need to cast Author to Writer explicitly, it's as simple as shown below:

Author a = new Author
{
    First = "Vijaya",
    Last = "Anand",
    BooksArray = new string[] { "book1" }
};
Writer w = (Writer)a; //explicitly casting from Author to Writer.

To cast the Writer instance back to Author, we can have another static method having the name Author.

public static explicit operator Author(Writer w)
{
    return new Author
    {
        First = w.FirstName,
        Last = w.LastName,
        BooksArray = w.Books != null ? w.Books.ToArray() : null
    };
}

For implicit casting, we have to follow the same steps as above except we have to use the implicit keyword instead of explicit.

public static implicit operator Writer(Author a)
{
    return new Writer
    {
        FirstName = a.First,
        LastName = a.Last,
        Books = a.BooksArray != null ? a.BooksArray.ToList() : null
    };
}

Now implicit casting is as simple as:

Author a = new Author
{
    First = "Vijaya",
    Last = "Anand",
    BooksArray = new string[] { "book1" }
};
Writer w = a; //implicitly casting from Author to Writer.

Whenever we do implicit or explicit casting, the corresponding static method will be called.

Summary

After playing around with implicit and explicit casting in user-defined types for a while, I would like to summarize some points I learnt:

1. We can have the conversion operator methods in any class. For example, if you create a static method that casts Author to Writer, that can be located in either the Author class or the Writer class.
2. We can't have both explicit and implicit operator methods for casting the same type to another. For example, if you already created a method for explicit casting from Author to Writer, you can't have another method for casting implicitly from Author to Writer.
3. The implicit conversion method can also be used for explicit. For example, if there is an implicit conversion method that converts Author to Writer and you are explicitly casting Author to Writer, the casting still works.

That's all! Hope you enjoyed it. Please drop your comments and votes.

History

• 12 April - Added History section.
• 7 April - Added Summary section.
• 6 April - Fixed the static field issue.