explicit (Riferimenti per C#)
Aggiornamento: novembre 2007
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(Fahrenheit f)
{
return new Celsius((5.0f / 9.0f) * (f.degrees - 32));
}
Questo operatore di conversione può essere richiamato nel seguente modo:
Fahrenheit f = new Fahrenheit(100.0f);
Console.Write("{0} fahrenheit", f.Degrees);
Celsius c = (Celsius)f;
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 la classe 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.
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
*/
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.
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
*/
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#)
Concetti
Riferimenti
Altre risorse
Chained user-defined explicit conversions in C# (informazioni in lingua inglese)