explícita (translation from VPE for Csharp Reference)

Artigo
08/25/2010

The explicit palavra-chave declara um operador de conversão de tipo definido pelo usuário deve ser chamado com uma projeção. Por exemplo, esse operador é convertido de uma classe chamada 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));
}

Este 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;

Converte o operador de conversão de um tipo de fonte para um tipo de destino.O tipo de fonte fornece o operador de conversão.Ao contrário de conversão implícita, operadores de conversão explícita devem ser chamados 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 invocando a operação de conversão com conseqüências imprevisíveis possivelmente silenciosamente.

Omitindo os resultados da conversão no erro em time de compilar CS0266 de erro do compilador.

Para obter mais informações, consulte Usando operadores de conversão (guia de programação translation from VPE for Csharp).

Exemplo

O exemplo a seguir fornece um Fahrenheit e um Celsius classe, cada um deles fornece um operador de conversão explícita para a Outros 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 as seções a seguir no Especificação da linguagem C#:

6.2 Conversões explícitas

Consulte também

explícita (translation from VPE for Csharp Reference)

Exemplo

Especificação da linguagem C#

Consulte também

Tarefas

Conceitos

Referência

Outros recursos

Recursos adicionais