En C#, los operadores implicit y explicit nos permiten definir conversiones personalizadas entre tipos. Esto es útil cuando trabajamos con estructuras o clases que representan conceptos que pueden transformarse naturalmente en otros valores, como metros a kilómetros, grados a radianes, o monedas.
Cuando diseñamos tipos personalizados, muchas veces necesitamos que se comporten como si fueran valores comunes. Por ejemplo, si tenemos un struct Metros, queremos poder escribir:
Metros distancia = 100.0;
En lugar de tener que usar un constructor o un método auxiliar. O, si ya tenemos un objeto de tipo Metros, queremos poder convertirlo a double sin esfuerzo.
Sin conversiones definidas, tendríamos que hacer algo como:
var distancia = new Metros(100.0);
double d = distancia.Valor;
Definiendo operadores de conversión, podemos hacer que esta interacción sea más fluida.
El modificador implicit permite definir una conversión automática cuando no hay pérdida de información. El compilador permitirá esta conversión sin necesidad de cast.
Por ejemplo:
public struct Metros
{
public double Valor { get; }
public Metros(double valor) => Valor = valor;
public static implicit operator Metros(double valor) => new Metros(valor);
}
Uso:
Metros distancia = 100.0; // conversión implícita desde double
Cuando una conversión puede perder información, o puede fallar, se recomienda marcarla como explicit. Esto obliga al programador a escribir el cast, dejando claro que está realizando una operación que podría tener consecuencias.
Por ejemplo:
public static explicit operator double(Metros metros) => metros.Valor;
Uso:
double d = (double)distancia; // cast explícito requerido
Las conversiones implicit y explicit en C# permiten diseñar APIs más amigables, legibles y seguras. Usá implicit cuando estés seguro de que la conversión no va a fallar ni perder datos, y explicit cuando quieras que el programador sea consciente del riesgo de la conversión.
