C# Academy · Les

Impliciete en expliciete conversies

Converteer veilig tussen compatibele types.

Les 3 van 413 stappen

Impliciete en expliciete conversies is een gratis C# Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Conversies tussen typen

C# kan het ene numerieke type naar het andere converteren. Sommige conversies gebeuren automatisch (impliciet), terwijl voor andere een expliciete cast nodig is.

using System;

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

Impliciete (verbredende) conversies

Een impliciete conversie is toegestaan wanneer er geen gegevens verloren kunnen gaan, zoals van int naar long of van int naar double. Een cast is niet nodig.

using System;

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

Waarom verbreden veilig is

Het doeltype kan elke waarde van het brontype voorstellen, dus staat de compiler dit stilzwijgend toe.

using System;

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

Expliciete (vernauwende) conversies

Een expliciete conversie (een cast) is nodig wanneer er gegevens verloren kunnen gaan, zoals van double naar int. Je schrijft (int)value.

using System;

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

Een cast kapt af en rondt niet af

Bij het casten van een kommagetal naar een geheel getal wordt het fractionele deel verwijderd; de waarde wordt niet afgerond. Gebruik eerst Math.Round als je wilt afronden.

using System;

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

Overloop bij vernauwen

Als een waarde niet in het doeltype past, kan een gewone cast stilzwijgend terugrollen. Zet de bewerking in checked om in plaats daarvan een fout bij overloop te veroorzaken.

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

Precisieverlies

Zelfs bij sommige verbredende conversies, zoals van een zeer grote long naar float, kan precisie verloren gaan, ook al zijn ze impliciet.

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

char- en numerieke conversies

Een char wordt impliciet geconverteerd naar de numerieke code ervan, en je kunt een getal expliciet terug casten naar een 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);
    }
}

Conversies in expressies

Bij gemengde rekenkundige bewerkingen worden kleinere typen automatisch naar het grotere type gepromoveerd voordat de bewerking wordt uitgevoerd.

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

Valkuil bij gehele deling

Als beide operanden gehele getallen zijn, is de deling een gehele deling. Cast er eerst één naar double om een resultaat met decimalen te krijgen.

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

Alles bij elkaar

Gebruik bij voorkeur impliciete conversies wanneer dat veilig is, gebruik expliciete casts bij vernauwende conversies en let op afkappen, overloop en gehele deling.

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

Korte test

Test je begrip van conversies.

Beantwoord dit in de interactieve les

Samenvatting

Impliciete (verbredende) conversies gebeuren automatisch wanneer er geen gegevens verloren gaan (int naar long, int naar double). Voor expliciete (vernauwende) conversies is een cast nodig, zoals (int)x, en daarbij kunnen waarden worden afgekapt of kan overloop optreden. Gebruik checked om overloop te detecteren en cast naar double om gehele deling te vermijden.

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 beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Impliciete en expliciete conversies” gratis?

Ja — de volledige tekst van “Impliciete en expliciete conversies” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “Impliciete en expliciete conversies”?

Converteer veilig tussen compatibele types. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Impliciete en expliciete conversies”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C# Academy