C# Academy · Lezione

Conversioni implicite ed esplicite

Converta in sicurezza tra tipi compatibili.

Conversioni implicite ed esplicite è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Conversione tra tipi

C# può convertire un tipo numerico in un altro. Alcune conversioni avvengono automaticamente (implicite), mentre per altre è necessario un cast esplicito.

using System;

class Program
{
    static void Main()
    {
        int i = 10;
        double d = i;       // implicit
        int back = (int)d;   // explicit
        Console.WriteLine(d + ", " + back);
    }
}

Conversioni implicite (widening)

Una conversione implicita è consentita quando non si può perdere alcun dato, ad esempio da int a long o da int a double. Non è necessario alcun cast.

using System;

class Program
{
    static void Main()
    {
        int i = 42;
        long l = i;      // widening, safe
        double d = i;    // widening, safe
        Console.WriteLine(l + ", " + d);
    }
}

Perché il widening è sicuro

Il tipo di destinazione può rappresentare ogni valore del tipo di origine, quindi il compilatore consente la conversione senza richiederne l'indicazione esplicita.

using System;

class Program
{
    static void Main()
    {
        byte b = 200;
        int i = b;       // byte fits in int
        Console.WriteLine("byte " + b + " -> int " + i);
    }
}

Conversioni esplicite (narrowing)

Una conversione esplicita (un cast) è necessaria quando si potrebbero perdere dati, ad esempio da double a int. Si scrive (int)value.

using System;

class Program
{
    static void Main()
    {
        double d = 9.78;
        int i = (int)d;   // truncates toward zero -> 9
        Console.WriteLine(i);
    }
}

Il cast tronca, non arrotonda

Il cast di un valore con virgola mobile a un intero elimina la parte frazionaria; non arrotonda. Se desidera arrotondare, utilizzi prima Math.Round.

using System;

class Program
{
    static void Main()
    {
        double d = 7.99;
        Console.WriteLine("Cast: " + (int)d);
        Console.WriteLine("Round: " + (int)Math.Round(d));
    }
}

Overflow durante il narrowing

Se un valore non rientra nel tipo di destinazione, un cast semplice può causare un wraparound silenzioso. Racchiudere l'operazione in checked fa sì che venga generata un'eccezione in caso di overflow.

using System;

class Program
{
    static void Main()
    {
        int big = 300;
        byte wrapped = (byte)big;   // 300 wraps to 44
        Console.WriteLine("Wrapped: " + wrapped);

        try
        {
            byte safe = checked((byte)big);
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("checked caught overflow");
        }
    }
}

Perdita di precisione

Anche alcune conversioni da un tipo più piccolo a uno più grande, come quella da un long di dimensioni molto elevate a float, possono perdere precisione, pur rimanendo implicite.

using System;

class Program
{
    static void Main()
    {
        long big = 9007199254740993L;
        double approx = big;   // implicit, may lose precision
        Console.WriteLine("long: " + big);
        Console.WriteLine("double: " + approx.ToString("F0"));
    }
}

Conversioni tra char e tipi numerici

Un char viene convertito implicitamente nel relativo codice numerico; è possibile eseguire il cast esplicito di un numero nuovamente a char.

using System;

class Program
{
    static void Main()
    {
        char c = 'A';
        int code = c;          // implicit -> 65
        char next = (char)(code + 1);   // explicit -> B
        Console.WriteLine(code + " -> " + next);
    }
}

Conversioni nelle espressioni

Nelle operazioni aritmetiche miste, i tipi più piccoli vengono promossi automaticamente al tipo più grande prima dell'operazione.

using System;

class Program
{
    static void Main()
    {
        int a = 7;
        double b = 2;
        double result = a / b;   // a promoted to double -> 3.5
        Console.WriteLine(result);
    }
}

Problema della divisione intera

Se entrambi gli operandi sono interi, la divisione è intera. Esegua prima il cast di uno dei due a double per ottenere un risultato frazionario.

using System;

class Program
{
    static void Main()
    {
        int a = 7, b = 2;
        Console.WriteLine("int / int: " + (a / b));
        Console.WriteLine("with cast: " + ((double)a / b));
    }
}

Mettere tutto insieme

È preferibile usare conversioni implicite quando sono sicure, cast espliciti quando si riduce il tipo e prestare attenzione a troncamento, overflow e divisione intera.

using System;

class Program
{
    static void Main()
    {
        int total = 17, count = 5;
        double average = (double)total / count;   // cast to avoid integer division
        int rounded = (int)Math.Round(average);
        Console.WriteLine("avg=" + average + ", rounded=" + rounded);
    }
}

Verifica rapida

Verifichi la comprensione delle conversioni.

Riepilogo

Le conversioni implicite (widening) avvengono automaticamente quando non si perdono dati (da int a long, da int a double). Le conversioni esplicite (narrowing) richiedono un cast come (int)x e possono troncare o causare overflow. Utilizzi checked per rilevare gli overflow ed esegua il cast a double per evitare la divisione intera.

using System;

class Program
{
    static void Main()
    {
        double d = 3.9;
        int i = (int)d;     // explicit, truncates to 3
        long l = i;          // implicit widening
        Console.WriteLine(i + ", " + l);
    }
}

Domande Frequenti

La lezione «Conversioni implicite ed esplicite» è gratuita?

Sì — il testo completo di «Conversioni implicite ed esplicite» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Conversioni implicite ed esplicite»?

Converta in sicurezza tra tipi compatibili. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Conversioni implicite ed esplicite»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy