(C# referência explícita)

Artigo
08/04/2011

O explicit palavra-chave declara um operador de conversão de tipo definido pelo usuário que deve ser chamado com um cast. Por exemplo, esse operador é convertido de uma classe denominada Fahrenheit para uma classe chamada Celsius:

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

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

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

O operador de conversão converte de um tipo de origem para um tipo de destino. O tipo de origem fornece o operador de conversão. Ao contrário de conversão implícita, operadores de conversão explícita devem ser invocados por meio de uma projeção. Se uma operação de conversão pode causar exceções ou perda de informações, você deverá marcá-la explicit. Isso impede que o compilador silenciosamente invocando a operação de conversão com conseqüências imprevisíveis possivelmente.

Omitindo os resultados da conversão em tempo de compilação erro CS0266.

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

Exemplo

O exemplo a seguir fornece uma Fahrenheit e um Celsius classe, cada um deles fornece um operador de conversão explícita para a 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 Farenheit:
    public static explicit operator Celsius(Fahrenheit f)
    {
        return new Celsius((5.0f / 9.0f) * (f.degrees - 32));
    }
    public float Degrees
    {
        get { return degrees; }
    }
    private float degrees;
}

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

        Console.Write(" = {0} celsius", c.Degrees);
        Fahrenheit f2 = (Fahrenheit)c;
        Console.WriteLine(" = {0} fahrenheit", f2.Degrees);
    }
}
/*
Output:
100 fahrenheit = 37.77778 celsius = 100 fahrenheit
*/

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

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 C# Language Specification A especificação de linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Compartilhar via

(C# referência explícita)

Exemplo

Especificação da linguagem C#

Consulte também

Tarefas

Referência

Conceitos

Outros recursos

Recursos adicionais