Oefening: gegevenstypecasting en conversie verkennen

30 minuten

Er zijn meerdere technieken om een gegevenstypeconversie uit te voeren. De techniek die u kiest, is afhankelijk van uw antwoord op twee belangrijke vragen:

Is het mogelijk dat afhankelijk van de waarde, een poging om het gegevenstype van de waarde te wijzigen, een uitzondering veroorzaakt tijdens runtime?
Is het mogelijk dat afhankelijk van de waarde, een poging om het gegevenstype van de waarde te wijzigen gegevensverlies veroorzaakt?

In deze oefening doorloopt u deze vragen, de implicaties van hun antwoorden en welke techniek u moet gebruiken wanneer u het gegevenstype wilt wijzigen.

Uw coderingsomgeving voorbereiden

Deze module bevat praktische activiteiten die u begeleiden bij het bouwen en uitvoeren van demonstratiecode. U wordt aangeraden deze activiteiten uit te voeren met Behulp van Visual Studio Code als uw ontwikkelomgeving. Het gebruik van Visual Studio Code voor deze activiteiten helpt u om comfortabeler code te schrijven en uit te voeren in een ontwikkelomgeving die wordt gebruikt door professionals over de hele wereld.

Notitie

Als u andere Microsoft Learn-modules in deze C#-serie hebt voltooid, hebt u mogelijk al een projectmap gemaakt voor codevoorbeelden. Als dat het geval is, kunt u de volgende sectie met stappen overslaan en de code verwijderen in het Program.cs bestand dat voor een vorige oefening is gebruikt.

Notitie

De codevoorbeelden in deze oefening zijn ontworpen op basis van en-US-cultuurinstellingen en gebruiken een punt (.) als decimaalteken. Het bouwen en uitvoeren van de code met een cultuurinstelling die gebruikmaakt van een ander decimaalteken (zoals een komma ,) kan onverwachte resultaten of fouten opleveren. U kunt dit probleem oplossen door de puntdecimaaltekens in de codevoorbeelden te vervangen door het lokale decimaalteken (zoals ,). Als u een programma wilt uitvoeren met behulp van de en-US-cultuurinstelling, voegt u de volgende code toe aan het begin van uw programma: using System.Globalization; en nadat andere using instructies zijn toegevoegd CultureInfo.CurrentCulture = new CultureInfo("en-US");.

Open Visual Studio Code.

U kunt de Windows-Startmenu (of een equivalente resource voor een ander besturingssysteem) gebruiken om Visual Studio Code te openen.
Selecteer Map openen in het menu Visual Studio Code-bestand.
Navigeer in het dialoogvenster Map Openen naar de map Windows-bureaublad.

Als u een andere maplocatie hebt waar u codeprojecten bewaart, kunt u die maplocatie gebruiken. Voor deze training is het belangrijk om een locatie te hebben die gemakkelijk te vinden en te onthouden is.
Selecteer in het dialoogvenster Map openen de optie Map selecteren.

Als u een beveiligingsdialoogvenster ziet waarin u wordt gevraagd of u de auteurs vertrouwt, selecteert u Ja.
Selecteer In het menu Visual Studio Code Terminalde optie Nieuwe terminal.

U ziet dat in een opdrachtprompt in het terminalvenster het mappad voor de huidige map wordt weergegeven. Voorbeeld:
```
C:\Users\someuser\Desktop>
```
Als u een nieuwe consoletoepassing in een opgegeven map wilt maken, typt u de Terminal-opdrachtprompt en dotnet new console -o ./CsharpProjects/TestProject drukt u vervolgens op Enter.

Deze .NET CLI-opdracht maakt gebruik van een .NET-programmasjabloon om een nieuw C#-consoletoepassingsproject te maken op de opgegeven maplocatie. Met de opdracht worden de mappen CsharpProjects en TestProject voor u gemaakt en wordt TestProject gebruikt als de naam van het .csproj bestand.
Vouw in het deelvenster EXPLORER de map CsharpProjects uit.

U ziet de map TestProject en twee bestanden, een C#-programmabestand met de naam Program.cs en een C#-projectbestand met de naam TestProject.csproj.
Selecteer Program.cs in het deelvenster Editor om uw codebestand in het deelvenster Editor weer te geven.
Verwijder de bestaande coderegels.

U gebruikt dit C#-consoleproject om codevoorbeelden te maken, te bouwen en uit te voeren tijdens deze module.
Sluit het deelvenster Terminal.

Vraag: Is het mogelijk dat een poging om het gegevenstype van de waarde te wijzigen een uitzondering genereert tijdens runtime?

De C#-compiler probeert ruimte te bieden aan uw code, maar compileert geen bewerkingen die kunnen leiden tot een uitzondering. Wanneer u de belangrijkste zorg van de C#-compiler begrijpt, is het gemakkelijker om te begrijpen waarom deze op een bepaalde manier functioneert.

Code schrijven die probeert een `int` en een `string` toe te voegen en het resultaat op te slaan in een `int`

Zorg ervoor dat Visual Studio Code is geopend en Program.cs weergegeven in het deelvenster Editor.

Notitie

Program.cs moet leeg zijn. Als dat niet het is, selecteert en verwijdert u alle coderegels.
Typ de volgende code in de Visual Studio Code-editor:
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Hier probeert u de waarden 2 en 4. De waarde 4 is van het type string. Werkt dit?
Selecteer Opslaan in het menu Visual Studio Code File.

Het Program.cs-bestand moet worden opgeslagen voordat u de code bouwt of uitvoert.
Klik in het deelvenster EXPLORER om een Terminal te openen op de locatie van de map TestProject met de rechtermuisknop op TestProject en selecteer Vervolgens Openen in geïntegreerde terminal.

Er moet een terminalvenster worden geopend en moet een opdrachtprompt bevatten die laat zien dat de Terminal is geopend voor de locatie van de testproject-map.
Typ in de Terminal-opdrachtprompt uw code en druk op Enter om uw code dotnet run uit te voeren.

Als het goed is, ziet u de volgende geschatte uitvoer
```
C:\Users\someuser\Desktop\csharpprojects\TestProject\Program.cs(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'
```
Notitie

Als er een bericht wordt weergegeven met de tekst 'Kan een project niet vinden om uit te voeren', controleert u of in de Terminal-opdrachtprompt de verwachte locatie van de testprojectmap wordt weergegeven. Bijvoorbeeld: C:\Users\someuser\Desktop\csharpprojects\TestProject>
Neem even de tijd om na te gaan waarom de compiler het eerste codevoorbeeld niet kon uitvoeren.

Het belangrijke onderdeel van het foutbericht, (3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'geeft aan dat het probleem het gebruik van het string gegevenstype is.

Maar waarom kan de C#-compiler de fout niet gewoon afhandelen? U kunt per slot van rekening het tegenovergestelde doen om een getal samen te voegen aan een string en deze op te slaan in een stringvariabele. Hier wijzigt u het gegevenstype van de result variabele in intstring.

Werk uw code als volgt bij in de Visual Studio Code-editor:

int first = 2;
string second = "4";
string result = first + second;
Console.WriteLine(result);

Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

U moet de volgende uitvoer bekijken:
```
24
```
De uitvoer is wiskundig onjuist, maar wordt voltooid door de waarden te combineren als de tekens '2' en '4'.
Bekijk opnieuw het eerste codevoorbeeld waarin de result variabele van het type intis. De code met het foutbericht.
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Waarom kan de C#-compiler niet achterhalen dat u de variabele second die als een getal bevat 4 , niet als een stringgetal wilt behandelen?

Compilers maken veilige conversies

De C#-compiler ziet een mogelijk probleem aankomen. De variabele second is van het type string, dus het is mogelijk dat deze wordt ingesteld op een andere waarde, zoals "hello". Als de C#-compiler zou proberen "hello" om te zetten in een getal, zou dat tijdens runtime een uitzondering veroorzaken. Om deze mogelijkheid te voorkomen, voert de C#-compiler de conversie string van naar int u niet impliciet uit.

Vanuit de C#-compiler gezien, is het veiliger om in plaats daarvan int om te zetten in een string en een samenvoeging uit te voeren.

Als u optellingen wilt uitvoeren met behulp van een tekenreeks, moet u voor de C#-compiler de controle over het gegevensconversieproces expliciet overnemen. Met andere woorden, de compiler dwingt u om meer betrokken te zijn, zodat u de juiste voorzorgsmaatregelen kunt treffen om de mogelijkheid te behandelen dat de conversie een uitzondering kan veroorzaken.

Als u een waarde van het oorspronkelijke gegevenstype wilt wijzigen in een nieuw gegevenstype en de wijziging tijdens runtime een uitzondering kan opleveren, moet u een gegevensconversie uitvoeren.

Er zijn verschillende technieken waarmee u een gegevensconversie kunt uitvoeren:

Een hulpmethode gebruiken op het gegevenstype
Een hulpmethode gebruiken op de variabele
De methoden van de Convert klasse gebruiken

Verderop in deze les bekijkt u enkele voorbeelden van deze technieken voor gegevensconversie.

Vraag: Is het mogelijk dat een poging om het gegevenstype van de waarde te wijzigen tot gegevensverlies leidt?

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:
```
int myInt = 3;
Console.WriteLine($"int: {myInt}");

decimal myDecimal = myInt;
Console.WriteLine($"decimal: {myDecimal}");
```
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

U moet de volgende uitvoer zien:
```
int: 3
decimal: 3
```
De sleutel tot dit voorbeeld is deze regel code:
```
decimal myDecimal = myInt;
```
Aangezien elke int-waarde gemakkelijk in een decimal past, voer de compiler de conversie uit.

De termverbreidingsconversie betekent dat u een waarde wilt converteren van een gegevenstype dat minder informatie kan bevatten naar een gegevenstype dat meer informatie kan bevatten. In dit geval verliest een waarde die is opgeslagen in een variabele van het type int die is geconverteerd naar een variabele van het type decimal, geen informatie.

Wanneer u weet dat u een widening conversie uitvoert, kunt u vertrouwen op impliciete conversie. De compiler verwerkt impliciete conversies.

Een cast uitvoeren

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:
```
decimal myDecimal = 3.14m;
Console.WriteLine($"decimal: {myDecimal}");

int myInt = (int)myDecimal;
Console.WriteLine($"int: {myInt}");
```
Als u een cast wilt uitvoeren, gebruikt u de cast-operator () om een gegevenstype te omringen en plaatst u deze vervolgens naast de variabele die u wilt converteren (bijvoorbeeld: (int)myDecimal). U voert een expliciete conversie uit naar het gedefinieerde cast-gegevenstype (int).
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

U moet de volgende uitvoer zien:
```
decimal: 3.14
int: 3
```
De sleutel tot dit voorbeeld is deze regel code:
```
int myInt = (int)myDecimal;
```
De variabele myDecimal bevat een waarde die precisie na het decimaalteken heeft. Door de cast-instructie (int)toe te voegen, vertelt u de C#-compiler dat u begrijpt dat het mogelijk is dat u die precisie verliest. In deze situatie is het prima. U vertelt de compiler dat u een opzettelijke conversie uitvoert, een expliciete conversie.

Bepalen of uw conversie een 'widening conversie' of een 'narrowing conversion' is

De term voor het beperken van conversie betekent dat u een waarde wilt converteren van een gegevenstype dat meer informatie kan bevatten naar een gegevenstype dat minder informatie kan bevatten. In dit geval kunt u informatie kwijtraken, zoals precisie (het aantal cijfers achter de komma). Een voorbeeld is het converteren van waarde die is opgeslagen in een variabele van het type decimal in een variabele van het type int. Als u de twee waarden afdrukt, ziet u mogelijk het verlies van informatie.

Wanneer u weet dat u een vernauwende conversie uitvoert, moet u een cast uitvoeren. Cast-conversie is een instructie aan de C#-compiler waarmee u aangeeft dat u weet dat er mogelijk precisie verloren gaat, maar dat u bereid bent dat te accepteren.

Als u niet zeker weet of u gegevens kwijtraakt in de conversie, schrijft u code om een conversie op twee verschillende manieren uit te voeren en bekijkt u de wijzigingen. Ontwikkelaars schrijven regelmatig kleine tests om meer inzicht te krijgen in het gedrag, zoals geïllustreerd in het volgende voorbeeld.

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:

decimal myDecimal = 1.23456789m;
float myFloat = (float)myDecimal;

Console.WriteLine($"Decimal: {myDecimal}");
Console.WriteLine($"Float  : {myFloat}");

Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

De uitvoer moet er ongeveer zo uitzien:
```
Decimal: 1.23456789
Float  : 1.2345679
```
U kunt vanuit de uitvoer zien dat het casten van een decimal in een float is een smalle conversie omdat u precisie verliest.

Gegevensconversies uitvoeren

Eerder werd aangegeven dat een waardewijziging van het ene gegevenstype naar het andere een runtime-uitzondering kan veroorzaken en dat u gegevensconversie moet uitvoeren. Voor gegevensconversies zijn er drie technieken die u kunt gebruiken:

Een hulpmethode gebruiken op de variabele
Een hulpmethode gebruiken op het gegevenstype
De methoden van de Convert klasse gebruiken

Gebruiken `ToString()` om een getal te converteren naar een `string`

Elke gegevenstypevariabele heeft een ToString()-methode. Wat de methode ToString() doet, is afhankelijk van de implementatie ervan voor van een bepaald type. Op de meeste primitieven wordt met deze methode echter een widening conversie uitgevoerd. Hoewel dit niet strikt noodzakelijk is (omdat u in de meeste gevallen kunt vertrouwen op impliciete conversie) kan het communiceren met andere ontwikkelaars die begrijpen wat u doet en dat het opzettelijk is.

Hier volgt een kort voorbeeld van het gebruik van de methode ToString() om int-waarden expliciet te converteren naar strings.

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:
```
int first = 5;
int second = 7;
string message = first.ToString() + second.ToString();
Console.WriteLine(message);
```
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren. Wanneer u de code uitvoert, moet in de uitvoer een samenvoeging van de twee waarden worden weergegeven:
```
57
```

`string` Een converteren naar een `int` met behulp van de `Parse()` helpermethode

De meeste numerieke gegevenstypen hebben een Parse() methode, waarmee een tekenreeks wordt geconverteerd naar het opgegeven gegevenstype. In dit geval gebruikt u de Parse() methode om twee tekenreeksen te converteren naar int waarden en deze vervolgens samen te voegen.

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:
```
string first = "5";
string second = "7";
int sum = int.Parse(first) + int.Parse(second);
Console.WriteLine(sum);
```
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren. Wanneer u de code uitvoert, moet in de uitvoer een som van de twee waarden worden weergegeven:
```
12
```
Neem even de tijd om het potentiële probleem met het vorige codevoorbeeld te herkennen? Wat als een van de variabelen first of second wordt ingesteld op een waarde die niet naar een int kan worden geconverteerd? Er wordt tijdens runtime een uitzondering gegenereerd. De C#-compiler en runtime verwacht dat u vooruit plant en 'illegale' conversies voorkomt. U kunt de runtime-uitzondering op verschillende manieren beperken.

De eenvoudigste manier om deze situatie te verhelpen is door een betere versie van de TryParse() methode te gebruikenParse().

`string` Een converteren naar een `int` met behulp van de `Convert` klasse

De Convert klasse heeft veel helpermethoden om een waarde van het ene type naar het andere te converteren. In het volgende codevoorbeeld converteert u een aantal tekenreeksen naar waarden van het type int.

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:
```
string value1 = "5";
string value2 = "7";
int result = Convert.ToInt32(value1) * Convert.ToInt32(value2);
Console.WriteLine(result);
```
Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

U moet de volgende uitvoer zien:
```
35
```
Notitie

Waarom is de naam van de methode ToInt32()? Waarom niet ToInt()? System.Int32 is de naam van het onderliggende gegevenstype in de .NET Framework-klassebibliotheek die in de computertaal C# overeenkomt met het sleutelwoord int. Omdat de Convert-klasse ook deel uitmaakt van de .NET-klassebibliotheek, wordt deze bij zijn volledige naam genoemd en niet bij zijn C#-naam. Door gegevenstypen te definiëren als deel van de .NET Framework-klassebibliotheek, kunnen meerdere .NET-talen, zoals Visual Basic, F#, IronPython en andere, dezelfde gegevenstypen delen en gebruikmaken van dezelfde klassen in de .NET Framework-klassebibliotheek.

De ToInt32() methode heeft 19 overbelaste versies, zodat deze vrijwel elk gegevenstype kan accepteren.

u de Convert.ToInt32() methode hier met een tekenreeks hebt gebruikt, maar u moet waarschijnlijk indien mogelijk gebruiken TryParse() .

Wanneer moet u de Convert klas gebruiken? De Convert klasse is het beste voor het converteren van breuknummers naar gehele getallen (int), omdat deze naar boven wordt afgerond zoals u zou verwachten.

Cast-conversie vergelijken en een `decimal` converteren naar een `int`

Het volgende voorbeeld laat zien wat er gebeurt wanneer u probeert een decimal naar een int te casten (een narrowing conversie) vergeleken met het gebruiken van de Convert.ToInt32()-methode om dezelfde decimal te converteren naar een int.

Verwijder of gebruik de operator // voor regelopmerking om de code uit de vorige oefeningsstap commentaar te geven en voeg de volgende code toe:

int value = (int)1.5m; // casting truncates
Console.WriteLine(value);

int value2 = Convert.ToInt32(1.5m); // converting rounds up
Console.WriteLine(value2);

Sla uw codebestand op en gebruik Visual Studio Code om uw code uit te voeren.

U moet de volgende uitvoer zien:
```
1
2
```

Cast kapt af en converteert rondes

Wanneer u castt int value = (int)1.5m;, wordt de waarde van de float afgekapt zodat het resultaat is 1, wat betekent dat de waarde na het decimaal volledig wordt genegeerd. U kunt de letterlijke float wijzigen in 1.999m en het resultaat van cast-conversie zou hetzelfde zijn.

Wanneer u converteert met behulp Convert.ToInt32()van, wordt de letterlijke float-waarde naar behoren afgerond naar 2. Als u de letterlijke waarde 1.499mwijzigt in , wordt deze naar beneden afgerond.1

Samenvatting

U hebt verschillende belangrijke concepten besproken van gegevensconversie en cast-conversie:

Een runtimefout voorkomen tijdens het uitvoeren van een gegevensconversie
Voer een expliciete cast uit om de compiler te vertellen dat u het risico begrijpt dat gegevens verloren gaan
Vertrouw op de compiler om een impliciete cast uit te voeren bij het uitvoeren van een groeiende conversie
Gebruik de () cast-operator en het gegevenstype om een cast uit te voeren (bijvoorbeeld (int)myDecimal)
Gebruik de Convert klasse als u een vermalende conversie wilt uitvoeren, maar afronding wilt uitvoeren, niet een afkapping van gegevens

Feedback

Is deze pagina nuttig?

Oefening: gegevenstypecasting en conversie verkennen

Kennis testen

Feedback