Implicit and Explicit Operator

• Implicit and Explicit Operator

Os operadores implicit e explicit no C# são usados para definir conversões personalizadas entre tipos de dados. Eles permitem que você controle como os objetos de um tipo podem ser convertidos para outro tipo, seja de maneira implícita ou explícita. Aqui está uma visão geral de como eles funcionam:

1. Operador implicit

• Usado para criar conversões que podem ser realizadas automaticamente (ou implicitamente) sem a necessidade de um cast explícito pelo programador.
• Essas conversões devem ser seguras e livres de perda de dados ou informações.

Exemplo de uso do implicit:

public class Celsius
{
    public double Degrees { get; }

    public Celsius(double degrees)
    {
        Degrees = degrees;
    }

    // Conversão implícita de double para Celsius
    public static implicit operator Celsius(double degrees)
    {
        return new Celsius(degrees);
    }

    // Conversão implícita de Celsius para double
    public static implicit operator double(Celsius celsius)
    {
        return celsius.Degrees;
    }
}

class Program
{
    static void Main()
    {
        Celsius temp = 37.5;  // Conversão implícita de double para Celsius
        double degrees = temp; // Conversão implícita de Celsius para double

        Console.WriteLine($"Temperatura em Celsius: {temp.Degrees}");
        Console.WriteLine($"Temperatura como double: {degrees}");
    }
}

Saída:

Temperatura em Celsius: 37.5
Temperatura como double: 37.5

---

2. Operador explicit

• Usado para conversões que podem não ser seguras ou que podem levar à perda de dados, requerendo que o programador indique explicitamente a conversão usando um cast.
• Essas conversões geralmente são mais arriscadas e requerem a atenção do desenvolvedor.

Exemplo de uso do explicit:

public class Fahrenheit
{
    public double Degrees { get; }

    public Fahrenheit(double degrees)
    {
        Degrees = degrees;
    }

    // Conversão explícita de Fahrenheit para Celsius
    public static explicit operator Celsius(Fahrenheit fahrenheit)
    {
        return new Celsius((fahrenheit.Degrees - 32) * 5 / 9);
    }

    // Conversão explícita de Celsius para Fahrenheit
    public static explicit operator Fahrenheit(Celsius celsius)
    {
        return new Fahrenheit(celsius.Degrees * 9 / 5 + 32);
    }
}

class Program
{
    static void Main()
    {
        Fahrenheit tempF = new Fahrenheit(100);
        
        // Requer conversão explícita
        Celsius tempC = (Celsius)tempF; 
        Fahrenheit tempF2 = (Fahrenheit)tempC;

        Console.WriteLine($"Temperatura em Fahrenheit: {tempF.Degrees}");
        Console.WriteLine($"Temperatura em Celsius: {tempC.Degrees}");
        Console.WriteLine($"Convertido de volta para Fahrenheit: {tempF2.Degrees}");
    }
}

Saída:

Temperatura em Fahrenheit: 100
Temperatura em Celsius: 37.77777777777778
Convertido de volta para Fahrenheit: 100

---

Diferenças principais entre implicit e explicit

Aspecto	implicit	explicit
Sintaxe	Sem necessidade de cast	Requer o uso de (TipoDestino)
Uso	Para conversões seguras e sem perda de dados	Para conversões que podem ser arriscadas
Intenção	Facilitar o uso em situações comuns	Garantir atenção especial do desenvolvedor
Exemplo de conversão	Celsius temp = 37.5;	Celsius temp = (Celsius)fahrenheit;