User-defined conversion operators (C# reference)
A user-defined type can define a custom implicit or explicit conversion from or to another type.
Implicit conversions don't require special syntax to be invoked and can occur in a variety of situations, for example, in assignments and methods invocations. Predefined C# implicit conversions always succeed and never throw an exception. User-defined implicit conversions should behave in that way as well. If a custom conversion can throw an exception or lose information, define it as an explicit conversion.
User-defined conversions are not considered by the is and as operators. Use a cast expression to invoke a user-defined explicit conversion.
Use the operator
and implicit
or explicit
keywords to define an implicit or explicit conversion, respectively. The type that defines a conversion must be either a source type or a target type of that conversion. A conversion between two user-defined types can be defined in either of the two types.
The following example demonstrates how to define an implicit and explicit conversion:
using System;
public readonly struct Digit
{
private readonly byte digit;
public Digit(byte digit)
{
if (digit > 9)
{
throw new ArgumentOutOfRangeException(nameof(digit), "Digit cannot be greater than nine.");
}
this.digit = digit;
}
public static implicit operator byte(Digit d) => d.digit;
public static explicit operator Digit(byte b) => new Digit(b);
public override string ToString() => $"{digit}";
}
public static class UserDefinedConversions
{
public static void Main()
{
var d = new Digit(7);
byte number = d;
Console.WriteLine(number); // output: 7
Digit digit = (Digit)number;
Console.WriteLine(digit); // output: 7
}
}
You also use the operator
keyword to overload a predefined C# operator. For more information, see Operator overloading.
C# language specification
For more information, see the following sections of the C# language specification:
See also
Feedback
Submit and view feedback for