Click here to Skip to main content
13,554,737 members
Click here to Skip to main content
Add your own
alternative version

Tagged as


20 bookmarked
Posted 5 Apr 2011
Licenced CPOL

Type conversions with implicit and explicit operators

, 12 Apr 2011
Rate this:
Please Sign up or sign in to vote.
This article helps to understand how to do user defined type conversions using implicit and explicit operators.


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!



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.


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.


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


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Software Developer Trigent Software Private Limited
India India
I'm a software developer from south tip of India. I spent most of the time in learning new technologies. I've a keen interest in client-side technologies especially JavaScript and admire it is the most beautiful language ever seen.

I like sharing my knowledge and written some non-popular articles. I believe in quality and standards but blames myself for lagging them.

I believe in small things and they makes me happy!

You may also be interested in...


Comments and Discussions

GeneralMy vote of 3 Pin
ervegter6-Apr-11 5:13
memberervegter6-Apr-11 5:13 
GeneralRe: My vote of 3 Pin
After20506-Apr-11 19:12
memberAfter20506-Apr-11 19:12 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.180515.1 | Last Updated 12 Apr 2011
Article Copyright 2011 by After2050
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid