explicit (Riferimenti per C#)

La parola chiave explicit dichiara un operatore di conversione di tipi definito dall'utente che è necessario richiamare con un cast. Il seguente operatore esegue ad esempio la conversione da una classe denominata Fahrenheit a una classe denominata Celsius:

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

Questo operatore di conversione può essere richiamato nel seguente modo:

Farenheit f = new Farenheit(100.0f);
Celsius c = (Celsius)f;

Note

L'operatore di conversione esegue la conversione da un tipo di origine a un tipo di destinazione. Il tipo di origine fornisce l'operatore di conversione. A differenza di quanto avviene per le conversioni implicite, gli operatori di conversione espliciti devono essere richiamati mediante un cast. Se un'operazione di conversione può provocare eccezioni o la perdita di informazioni, è opportuno contrassegnarla come explicit, per evitare che il compilatore richiami automaticamente l'operazione di conversione con conseguenze imprevedibili.

Se si omette il cast, verrà generato un errore in fase di compilazione Errore del compilatore CS0266.

Per ulteriori informazioni, vedere Utilizzo degli operatori di conversione (Guida per programmatori C#).

Esempio

Nell'esempio riportato di seguito vengono utilizzate una classe Fahrenheit e una classe Celsius, ciascuna delle quali fornisce un operatore di conversione esplicito all'altra classe.

// cs_keyword_explicit_temp.cs
using System;
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;
    }
    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

Nell'esempio riportato di seguito viene definita la struttura Digit che rappresenta una singola cifra decimale. Viene definito un operatore per le conversioni da byte a Digit; tuttavia, poiché non è possibile convertire tutti i byte in un valore Digit, la conversione è esplicita.

// cs_keyword_explicit_2.cs
using System;
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 MainClass
{
    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

Specifiche del linguaggio C#

Per ulteriori informazioni, vedere le sezioni riportate di seguito in Specifiche del linguaggio C#:

• 6.2 Conversioni esplicite

Vedere anche

Attività

Procedura: implementare conversioni tra strutture definite dall'utente (Guida per programmatori C#)

Riferimenti

Parole chiave di C#
implicit (Riferimenti per C#)
operator (Riferimenti per C#)

Concetti

Guida per programmatori C#

Altre risorse

Riferimenti per C#