C# Implicit Keyword

Implicit operators allow certain conversions. With the implicit keyword, you allow any conversion from one class to another without any syntax. This makes it possible to assign one class instance to another. No cast expressions are needed.

This C# example program uses the implicit operator. Implicit allows custom conversions.

Example

The implicit keyword is always used with the operator keyword. It requires a public static method that returns the type you want to convert to and accepts the type you are converting from. In this example, we provide a Machine class and a Widget class. The Machine class has an implicit conversion operator to the Widget class, and vice versa.

Program that uses implicit operator [C#]

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);
    }
}

Output

5
10
5

Implicit operator implementation. The implicit operators here convert the Machine and Widget types by manipulating their _value fields. The Widget and Machine may be conceptually equal but have a different representation of their data; the Widget's data is represented in an integer twice as large as the Machine.

Should I use it?

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. Numeric types can implement implicit conversions to some advantage. Implicit is not something that most programs will require.

To restate: No.

Summary

The keyword implicit provides a way to implement conversions. With implicit, you can end up with some baffling programming scenarios where an implicit conversion is not reversible. Typically it would be best to keep more complicated conversions more apparent. If something complex is happening it should be noted by all programmers.