Errore del compilatore CS0029

Non è possibile convertire in modo implicito il tipo 'tipo' in 'tipo'

Il compilatore richiede una conversione esplicita. Ad esempio, potrebbe essere necessario eseguire il cast di un r-value sullo stesso tipo di un l-value. Oppure, è necessario fornire routine di conversione per supportare determinati overload degli operatori.

Le conversioni devono essere eseguite quando si assegna una variabile di un tipo a una variabile di tipo diverso. Quando si effettua un'assegnazione tra variabili di tipi diversi, il compilatore deve convertire il tipo sul lato destro dell'operatore di assegnazione nel tipo sul lato sinistro dell'operatore di assegnazione. Si consideri il codice seguente:

int i = 50;
long lng = 100;
i = lng;

i = lng; esegue un'assegnazione, ma i tipi di dati delle variabili sul lato sinistro e destro dell'operatore di assegnazione non corrispondono. Prima di procedere all'assegnazione, il compilatore converte in modo implicito la variabile lng, che è di tipo long, in un int. Si tratta di un'operazione implicita perché non è presente codice che indica in modo esplicito al compilatore di eseguire questa conversione. Il problema con questo codice è che questa viene considerata una conversione verso un tipo di dati più piccolo e il compilatore non consente conversioni implicite verso un tipo di dati più piccolo a causa della potenziale perdita di dati.

Una conversione verso un tipo di dati più piccolo si verifica nel caso della conversione verso un tipo di dati che occupa meno spazio di archiviazione in memoria rispetto al tipo di dati da cui viene convertito. Ad esempio, la conversione di un valore long in int viene considerata una conversione verso un tipo di dati più piccolo. Un valore long occupa 8 byte di memoria, mentre un valore int occupa 4 byte. Per rendersi conto di come può verificarsi una perdita di dati, prendere in esame l'esempio seguente:

int i = 50;
long lng = 3147483647;
i = lng;

La variabile lng ora contiene un valore che non può essere archiviato nella variabile i perché è troppo grande. Se si dovesse convertire questo valore in un tipo int si potrebbero perdere alcuni dei dati e il valore convertito non sarebbe lo stesso del valore prima della conversione.

Una conversione verso un tipo di dati più grande sarebbe l'opposto. Una conversione verso un tipo di dati più grande si verifica nel caso della conversione di un tipo di dati che occupa più spazio di archiviazione in memoria rispetto al tipo di dati da cui viene convertito. Di seguito è riportato un esempio di conversione verso un tipo di dati più grande:

int i = 50;
long lng = 100;
lng = i;

Si noti la differenza tra questo esempio di codice e il primo. In questo caso, la variabile lng è sul lato sinistro dell'operatore di assegnazione, pertanto è la destinazione dell'assegnazione. Prima di procedere all'assegnazione, il compilatore deve convertire in modo implicito la variabile i, che è di tipo int, nel tipo long. Questa è una conversione verso un tipo di dati più grande, perché si converte un tipo che occupa 4 byte di memoria (int) in un tipo che occupa 8 byte di memoria (long). Le conversioni implicite verso un tipo di dati più grande sono consentite perché non è presente il rischio di perdita di dati. Qualsiasi valore che può essere archiviato in un int, può essere archiviato anche in un tipo long.

Sapendo che le conversioni implicite verso un tipo di dati più piccolo non sono consentite, per riuscire a compilare questo codice è necessaria la conversione esplicita del tipo di dati. Le conversioni esplicite vengono eseguite tramite casting. Il termine cast o casting viene usato in C# per indicare la conversione da un tipo di dati a un altro. Per ottenere la compilazione del codice, è necessario usare la sintassi seguente:

int i = 50;
long lng = 100;
i = (int) lng;   // Cast to int.

La terza riga di codice indica al compilatore di convertire in modo implicito la variabile lng, di tipo long, in int prima di procedere all'assegnazione. Tenere presente che con una conversione verso un tipo di dati più piccolo, esiste una potenziale perdita di dati. Le conversioni verso un tipo di dati più piccolo devono essere usate con cautela e anche se il codice viene compilato si potrebbero ottenere risultati imprevisti in fase di esecuzione.

Queste informazioni riguardano solo i tipi valore. Quando si usano i tipi valore, si opera direttamente sui dati archiviati nella variabile. Tuttavia, .NET include anche tipi riferimento. Con i tipi riferimento non si usano i dati effettivi, ma un riferimento a una variabile. Sono esempi di tipi riferimento le classi, le interfacce e le matrici. Non è possibile convertire in modo implicito o esplicito un tipo riferimento in un altro, a meno che il compilatore non consenta la conversione specifica o che non siano implementati gli operatori di conversione appropriati.

L'esempio seguente genera l'errore CS0029:

// CS0029.cs
public class MyInt
{
    private int x = 0;

    // Uncomment this conversion routine to resolve CS0029.
    /*
    public static implicit operator int(MyInt i)
    {
        return i.x;
    }
    */

    public static void Main()
    {
        var myInt = new MyInt();
        int i = myInt; // CS0029
    }
}

Vedi anche

• Operatori di conversione definiti dall'utente