Explicit, implicit

Explicit provides conversion functionality. An explicit conversion involves casting from one type to another.

With the explicit keyword, we implement the casting functionality as an operator method. This keyword (along with implicit) is used in operator overloading.

Example, explicit

This program shows 2 classes. Each provides a public static explicit operator: the Apartment provides a House operator, and the House provides an Apartment operator.

Here These explicit operators are implemented by constructing a new instance of the target type.

And They set the Name property. Thus the Apartment or House is now of the opposite type but has the same data field.

Info When you use a cast like (Apartment) or (House), this is an explicit cast. An implicit cast never uses this syntax.

using System;

class Apartment
{
    public string Name { get; set; }
    public static explicit operator House(Apartment a)
    {
        return new House() { Name = a.Name };
    }
}

class House
{
    public string Name { get; set; }
    public static explicit operator Apartment(House h)
    {
        return new Apartment() { Name = h.Name };
    }
}

class Program
{
    static void Main()
    {
        House h = new House();
        h.Name = "Broadway";

        // Cast a House to an Apartment.
        Apartment a = (Apartment)h;

        // Apartment was converted from House.
        Console.WriteLine(a.Name);
    }
}
Broadway

Example, implicit

With implicit, we allow a conversion from one class to another without any syntax. It is possible to assign one class instance to another. No cast expressions are needed.

Tip Implicit requires a public static method that returns the type you want to convert to and accepts the type you are converting from.

Next We provide a Machine class and a Widget class. Both classes have implicit conversion operators.

Detail The implicit operators here convert the Machine and Widget types by manipulating their _value fields.

And The Widget and Machine may be conceptually equal but have a different representation of their data.

using System;

class Machine
{
    public int _value;
    public static implicit operator Widget(Machine m)
    {
        Widget w = new Widget();
        w._value = m._value * 2;
        return w;
    }
}

class Widget
{
    public int _value;
    public static implicit operator Machine(Widget w)
    {
        Machine m = new Machine();
        m._value = w._value / 2;
        return m;
    }
}

class Program
{
    static void Main()
    {
        Machine m = new Machine();
        m._value = 5;
        Console.WriteLine(m._value);

        // Implicit conversion from machine to widget.
        Widget w = m;
        Console.WriteLine(w._value);

        // Implicit conversion from widget to machine.
        Machine m2 = w;
        Console.WriteLine(m2._value);
    }
}5
10
5

Discussion

What is the point of explicit? It provides a special syntax form for converting types. This can be more intuitive for certain operations, mainly ones that involve numeric types.

However For classes such as Apartment or House, an explicit operator is not normally needed or useful.

And The example here is for illustrative purposes. Explicit should be rarely used.

Discussion, implicit

You should only use the implicit operator if you are developing a commonly used type. It is probably most useful for the .NET Framework itself.

Thus Implicit is not something that most programs will require. It is worth knowing it exists, but not often useful.

As with implicit, the explicit keyword is used to implement conversions. You should be careful with implementing conversions so that they are reversible and make sense.