explicit (Referência de C#)

A palavra-chave declara um operador de explicit definido pelo usuário de conversão de tipos que deve ser chamado com uma conversão. Por exemplo, esse operador converte de uma classe chamada Fahrenheit para Celsius uma classe chamada:

// Must be defined inside a class called Fahrenheit: 
public static explicit operator Celsius(Fahrenheit fahr)
{
    return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32));
}

Este operador de conversão pode ser chamado como este:

Fahrenheit fahr = new Fahrenheit(100.0f);
Console.Write("{0} Fahrenheit", fahr.Degrees);
Celsius c = (Celsius)fahr;

Operador de conversão converte o de um tipo de origem para um tipo de destino. O tipo de fonte fornece o operador de conversão. Diferentemente de conversão implícita, os operadores de conversão explícita devem ser chamados por meio de uma conversão. Se uma operação de conversão pode causar exceções ou perde informações, você deve marcá-la explicit. Isso impede que o compilador chama silenciosamente a operação de conversão com as conseqüências possivelmente imprevisíveis.

Omitir a conversão resulta em CS0266 erro em tempo de compilação.

Para obter mais informações, consulte Usando operadores de conversão (Guia de Programação em C#).

Exemplo

O exemplo a seguir fornece Fahrenheit e uma classe de Celsius , cada um que fornece um operador de conversão explícita de outra classe.

class Celsius
{
    public Celsius(float temp)
    {
        degrees = temp;
    }
    public static explicit operator Fahrenheit(Celsius c)
    {
        return new Fahrenheit((9.0f / 5.0f) * c.degrees + 32);
    }
    public float Degrees
    {
        get { return degrees; }
    }
    private float degrees;
}

class Fahrenheit
{
    public Fahrenheit(float temp)
    {
        degrees = temp;
    }
    // Must be defined inside a class called Fahrenheit: 
    public static explicit operator Celsius(Fahrenheit fahr)
    {
        return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32));
    }
    public float Degrees
    {
        get { return degrees; }
    }
    private float degrees;
}

class MainClass
{
    static void Main()
    {
        Fahrenheit fahr = new Fahrenheit(100.0f);
        Console.Write("{0} Fahrenheit", fahr.Degrees);
        Celsius c = (Celsius)fahr;

        Console.Write(" = {0} Celsius", c.Degrees);
        Fahrenheit fahr2 = (Fahrenheit)c;
        Console.WriteLine(" = {0} Fahrenheit", fahr2.Degrees);
    }
}
// Output: 
// 100 Fahrenheit = 37.77778 Celsius = 100 Fahrenheit

O exemplo a seguir define uma estrutura, Digit, que representa um único dígito decimal. Um operador é definido para conversões de byte a Digit, mas porque nem todos os bytes podem ser convertidos em Digit, a conversão é explícito.

struct Digit
{
    byte value;
    public Digit(byte value)
    {
        if (value > 9)
        {
            throw new ArgumentException();
        }
        this.value = value;
    }

    // Define explicit byte-to-Digit conversion operator: 
    public static explicit operator Digit(byte b)
    {
        Digit d = new Digit(b);
        Console.WriteLine("conversion occurred");
        return d;
    }
}

class ExplicitTest
{
    static void Main()
    {
        try
        {
            byte b = 3;
            Digit d = (Digit)b; // explicit conversion
        }
        catch (Exception e)
        {
            Console.WriteLine("{0} Exception caught.", e);
        }
    }
}
/*
Output:
conversion occurred
*/

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Tarefas

Como implementar conversões definidas pelo usuário entre structs (Guia de Programação em C#)

Referência

Palavras-chave C#

implicit (Referência de C#)

operator (Referência de C#)

Conceitos

Guia de Programação em C#

Outros recursos

Referência de C#

conversões explícitas definidos pelo usuário encadeadas em C#