C# Academy · Lektion

Implicit och explicit konvertering

Konvertera säkert mellan kompatibla typer.

Lektion 3 av 413 steg

Implicit och explicit konvertering är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Konvertera mellan typer

C# kan konvertera en numerisk typ till en annan. Vissa konverteringar sker automatiskt (implicita), medan andra kräver en explicit cast.

using System;

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

Implicita (utvidgande) konverteringar

En implicit konvertering tillåts när inga data kan gå förlorade, till exempel från int till long eller från int till double. Ingen cast behövs.

using System;

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

Varför utvidgning är säker

Måldatatypen kan representera alla värden i källdatatypen, så kompilatorn tillåter konverteringen utan att kräva någon åtgärd.

using System;

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

Explicita (inskränkande) konverteringar

En explicit konvertering (en cast) krävs när data kan gå förlorade, till exempel från double till int. Ni skriver (int)value.

using System;

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

Casting trunkerar, avrundar inte

När ett flyttal konverteras till ett heltal tas decimaldelen bort; värdet avrundas inte. Använd Math.Round först om Ni vill avrunda.

using System;

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

Overflow vid inskränkning

Om ett värde inte ryms i måldatatypen kan en vanlig cast tyst slå runt. Omslut den med checked för att i stället utlösa ett undantag vid 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");
        }
    }
}

Förlust av precision

Även vissa utvidgande konverteringar, till exempel från ett mycket stort long till float, kan leda till förlorad precision trots att de är implicita.

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"));
    }
}

Konvertering mellan char och numeriska typer

En char konverteras implicit till sin numeriska kod, och Ni kan göra en explicit cast av ett tal tillbaka till en 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);
    }
}

Konverteringar i uttryck

I blandad aritmetik konverteras mindre typer automatiskt till den större typen innan operationen utförs.

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);
    }
}

Fallgrop vid heltalsdivision

Om båda operanderna är heltal blir divisionen heltalsdivision. Gör först en cast av den ena till double för att få ett resultat med decimaldel.

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));
    }
}

Sätt ihop delarna

Föredra implicita konverteringar när de är säkra, använd explicita castar vid inskränkande konverteringar och var uppmärksam på trunkering, overflow och heltalsdivision.

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);
    }
}

Snabbtest

Testa Er förståelse av konverteringar.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Implicita (utvidgande) konverteringar sker automatiskt när inga data går förlorade (int till long, int till double). Explicita (inskränkande) konverteringar kräver en cast som (int)x och kan trunkera eller orsaka overflow. Använd checked för att upptäcka overflow och casta till double för att undvika heltalsdivision.

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);
    }
}

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Implicit och explicit konvertering” gratis?

Ja – hela texten till ”Implicit och explicit konvertering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implicit och explicit konvertering”?

Konvertera säkert mellan kompatibla typer. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Implicit och explicit konvertering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C# Academy