Øvelse – Utforsk støping og konvertering av datatype

30 minutter

Det finnes flere teknikker for å utføre en datatypekonvertering. Teknikken du velger, avhenger av svaret ditt på to viktige spørsmål:

Er det mulig, avhengig av verdien, at forsøk på å endre verdiens datatype vil gi et unntak ved kjøring?
Er det mulig, avhengig av verdien, at forsøk på å endre verdiens datatype vil føre til tap av informasjon?

I denne øvelsen jobber du deg gjennom disse spørsmålene, konsekvensene av svarene og hvilken teknikk du bør bruke når du trenger å endre datatypen.

Klargjøre kodemiljøet

Denne modulen inneholder praktiske aktiviteter som veileder deg gjennom prosessen med å bygge og kjøre demonstrasjonskode. Du oppfordres til å fullføre disse aktivitetene ved hjelp av Visual Studio Code som utviklingsmiljø. Bruk av Visual Studio Code for disse aktivitetene hjelper deg med å bli mer komfortabel med å skrive og kjøre kode i et utviklermiljø som brukes av profesjonelle over hele verden.

Merk deg

Hvis du har fullført andre Microsoft Learn-moduler i denne C#-serien, kan det hende du allerede har opprettet en prosjektmappe for kodeeksempler. Hvis det er tilfelle, kan du hoppe over følgende del av trinnene og slette koden i Program.cs filen som ble brukt til en tidligere øvelse.

Merk deg

Kodeeksempler i denne øvelsen er utformet basert på en-US kulturinnstillinger, og bruker et punktum (.) som desimalskilletegn. Å bygge og kjøre koden med en kulturinnstilling som bruker forskjellige desimalskilletegn (for eksempel komma ,) kan gi uventede resultater eller feil. Hvis du vil løse dette problemet, erstatter du periodedesimalskilletegnene i kodeeksempler med det lokale desimalskilletegnet (for eksempel ,). Hvis du vil kjøre et program ved hjelp av en-US kulturinnstillingen, kan du legge til følgende kode øverst i programmet: using System.Globalization; og etter at andre using setninger legger til CultureInfo.CurrentCulture = new CultureInfo("en-US");.

Åpne Visual Studio Code.

Du kan bruke Start-menyen i Windows (eller tilsvarende ressurs for et annet operativsystem) til å åpne Visual Studio Code.
Velg Åpne mappe på Visual Studio Code File-menyen.
Gå til Windows-skrivebordsmappen i dialogboksen Åpne mappe .

Hvis du har en annen mappeplassering der du beholder kodeprosjekter, kan du bruke denne mappeplasseringen i stedet. For denne opplæringen er det viktig å ha en plassering som er enkel å finne og huske.
Velg Velg mappe i dialogboksen Åpne mappe.

Hvis du ser en sikkerhetsdialogboks som spør om du stoler på forfatterne, velger du Ja.
Velg Ny terminal på Visual Studio Code Terminal-menyen.

Legg merke til at en ledetekst i Terminal-panelet viser mappebanen for gjeldende mappe. Eksempel:
```
C:\Users\someuser\Desktop>
```
Hvis du vil opprette et nytt konsollprogram i en angitt mappe, skriver du inn Terminal-ledeteksten: dotnet new console -o ./CsharpProjects/TestProject og deretter trykker du ENTER.

Denne .NET CLI-kommandoen bruker en .NET-programmal til å opprette et nytt C#-konsollprogramprosjekt i den angitte mappeplasseringen. Kommandoen oppretter mappene CsharpProjects og TestProject for deg, og bruker TestProject som navnet på .csproj filen.
Utvid CsharpProjects-mappen i EXPLORER-panelet.

Du skal se TestProject-mappen og to filer, en C#-programfil med navnet Program.cs og en C#-prosjektfil kalt TestProject.csproj.
Velg Program.cs for å vise kodefilen i redigeringspanelet i EXPLORER-panelet.
Slett eksisterende kodelinjer.

Du bruker dette C#-konsollprosjektet til å opprette, bygge og kjøre kodeeksempler under denne modulen.
Lukk Terminal-panelet.

Spørsmål: Er det mulig at forsøk på å endre verdiens datatype vil gi et unntak ved kjøring?

C#-kompilatoren prøver å få plass til koden, men kompilerer ikke operasjoner som kan resultere i et unntak. Når du forstår C#-kompilatorens primære bekymring, er det enklere å forstå hvorfor den fungerer på en bestemt måte.

Skriv kode som prøver å legge til en `int` og en `string` og lagre resultatet i en `int`

Kontroller at Visual Studio Code er åpen og Program.cs vist i redigeringspanelet.

Merk deg

Program.cs skal være tom. Hvis ikke, velger og sletter du alle kodelinjer.
Skriv inn følgende kode i Visual Studio Code Editor:
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Her prøver du å legge til verdiene 2 og 4. Verdien 4 er av typen string. Vil dette fungere?
Velg Lagre på Visual Studio Code File-menyen.

Den Program.cs filen må lagres før du bygger eller kjører koden.
Høyreklikk på TestProjecti EXPLORER-panelet, og velg deretter Åpne i integrert terminal.

Et terminalpanel skal åpnes, og bør inneholde en ledetekst som viser at terminalen er åpen for plasseringen av TestProject-mappen.
Skriv inn dotnet run og trykk enter ved kommandoledeteksten terminalen for å kjøre koden.

Du bør se følgende omtrentlige utdata
```
C:\Users\someuser\Desktop\csharpprojects\TestProject\Program.cs(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'
```
Merk deg

Hvis du ser en melding som sier «Finner ikke et prosjekt å kjøre», må du kontrollere at terminalkommandoledeteksten viser den forventede plasseringen av TestProject-mappen. Eksempel: C:\Users\someuser\Desktop\csharpprojects\TestProject>
Ta et minutt å vurdere hvorfor kompilatoren ikke kunne kjøre det første kodeeksempelet.

Den viktige delen av feilmeldingen forteller (3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'deg at problemet er med bruken av string datatypen.

Men hvorfor kan ikke C# Compiler bare håndtere feilen? Tross alt kan du gjøre det motsatte for å kjede sammen et tall til en string og lagre det i en strengvariabel. Her endrer du datatypen for variabelen result fra int til string.

Oppdater koden i Visual Studio Code Editor på følgende måte:

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

Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden.

Du bør se følgende utdata:
```
24
```
Utdataene er matematisk feil, men fullføres ved å kombinere verdiene som tegnene "2" og "4".
Undersøk nok en gang det første kodeeksempelet der variabelen result er av typen int. Koden med feilmeldingen.
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Hvorfor kan ikke C#-kompilatoren finne ut at du vil behandle variabelen second som inneholder 4 som et tall, ikke et string?

Kompilatorer foretar sikre konverteringer

C#-kompilatoren ser et potensielt problem i opprettingen. Variabelen second er av typen string, så den kan være satt til en annen verdi som "hello". Hvis C#-kompilatoren prøvde å konvertere "hello" til et tall som ville forårsake et unntak ved kjøring. For å unngå denne muligheten utfører ikke C#-kompilatoren implisitt konverteringen fra string til int for deg.

Fra C#-kompilatorens perspektiv ville den sikrere operasjonen være å konvertere int til en string og utføre sammenkobling i stedet.

Hvis du har tenkt å utføre tillegg ved hjelp av en streng, krever C#-kompilatoren at du tar mer eksplisitt kontroll over prosessen med datakonvertering. Med andre ord, det tvinger deg til å være mer involvert slik at du kan sette de riktige forholdsregler på plass for å håndtere muligheten for at konverteringen kan kaste et unntak.

Hvis du må endre en verdi fra den opprinnelige datatypen til en ny datatype, og endringen kan gi et unntak ved kjøring, må du utføre en datakonvertering.

Hvis du vil utføre datakonvertering, kan du bruke én av flere teknikker:

Bruke en hjelpemetode på datatypen
Bruk en hjelpemetode på variabelen
Convert Bruk klassens metoder

Du ser på noen eksempler på disse teknikkene for datakonvertering senere i denne enheten.

Spørsmål: Er det mulig at forsøk på å endre verdiens datatype vil føre til tap av informasjon?

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:

int myInt = 3;
Console.WriteLine($"int: {myInt}");

decimal myDecimal = myInt;
Console.WriteLine($"decimal: {myDecimal}");

Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden.

Du skal se følgende utdata:
```
int: 3
decimal: 3
```
Nøkkelen til dette eksemplet er denne kodelinjen:
```
decimal myDecimal = myInt;
```
Siden en hvilken som helst int verdi enkelt kan passe inn i en decimal, utfører kompilatoren konverteringen.

Konvertering av termutvidelse betyr at du prøver å konvertere en verdi fra en datatype som kan inneholde mindre informasjon til en datatype som kan inneholde mer informasjon. I dette tilfellet mister ikke en verdi som er lagret i en variabel av typen int konvertert til en variabel av typen decimal, informasjon.

Når du vet at du utfører en større konvertering, kan du stole på implisitt konvertering. Kompilatoren håndterer implisitte konverteringer.

Utføre en avstøpning

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:
```
decimal myDecimal = 3.14m;
Console.WriteLine($"decimal: {myDecimal}");

int myInt = (int)myDecimal;
Console.WriteLine($"int: {myInt}");
```
Hvis du vil utføre en avstøpning, bruker du støpingsoperatoren () til å omslutte en datatype, og plasserer den ved siden av variabelen du vil konvertere (eksempel: (int)myDecimal). Du utfører en eksplisitt konvertering til den definerte cast-datatypen (int).
Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden.

Du skal se følgende utdata:
```
decimal: 3.14
int: 3
```
Nøkkelen til dette eksemplet er denne kodelinjen:
```
int myInt = (int)myDecimal;
```
Variabelen myDecimal har en verdi som har presisjon etter desimaltegnet. Ved å legge til støpeinstruksjonen (int)forteller du C#-kompilatoren at du forstår at det er mulig at du mister presisjonen, og i denne situasjonen er det greit. Du forteller kompilatoren at du utfører en bevisst konvertering, en eksplisitt konvertering.

Fastslå om konverteringen er en «utvidelseskonvertering» eller en «innsnevringskonvertering»

Konvertering av terminnsnevring betyr at du prøver å konvertere en verdi fra en datatype som kan inneholde mer informasjon til en datatype som kan inneholde mindre informasjon. I dette tilfellet kan du miste informasjon som presisjon (det vil si antall verdier etter desimaltegnet). Et eksempel er å konvertere verdien som er lagret i en typevariabel decimal , til en variabel av typen int. Hvis du skriver ut de to verdiene, vil du muligens legge merke til tap av informasjon.

Når du vet at du utfører en innsnevringskonvertering, må du utføre en avstøpning. Avstøpning er en instruksjon til C#-kompilatoren om at du vet at presisjon kan gå tapt, men du er villig til å godta den.

Hvis du er usikker på om du mister data i konverteringen, skriver du kode for å utføre en konvertering på to forskjellige måter og ser på endringene. Utviklere skriver ofte små tester for bedre å forstå virkemåten, som illustrert med neste eksempel.

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:

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

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

Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden.

Du bør se utdata som ligner på:
```
Decimal: 1.23456789
Float  : 1.2345679
```
Du kan se fra utdataene som kaster en decimal inn i en float er en innsnevring konvertering fordi du mister presisjon.

Utføre datakonverteringer

Tidligere ble det angitt at en verdiendring fra én datatype til en annen kan føre til et kjøretidsunntak, og du bør utføre datakonvertering. For datakonverteringer finnes det tre teknikker du kan bruke:

Bruk en hjelpemetode på variabelen
Bruke en hjelpemetode på datatypen
Convert Bruk klassens metoder

Brukes `ToString()` til å konvertere et tall til et `string`

Hver datatypevariabel har en ToString() metode. Hva metoden gjør, avhenger av hvordan den ToString() implementeres på en gitt type. Men på de fleste primitiver utfører den en bredere konvertering. Selv om dette ikke er strengt nødvendig (siden du kan stole på implisitt konvertering i de fleste tilfeller) kan det kommunisere til andre utviklere at du forstår hva du gjør, og det er tilsiktet.

Her er et raskt eksempel på ToString() hvordan du bruker metoden til eksplisitt å konvertere int verdier til strings.

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:
```
int first = 5;
int second = 7;
string message = first.ToString() + second.ToString();
Console.WriteLine(message);
```
Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden. Når du kjører koden, skal utdataene vise en sammenkobling av de to verdiene:
```
57
```

Konvertere en `string` til en `int` bruker av hjelpemetoden `Parse()`

De fleste av de numeriske datatypene har en Parse() metode som konverterer en streng til den angitte datatypen. I dette tilfellet bruker Parse() du metoden til å konvertere to strenger til int verdier, og deretter legge dem sammen.

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:
```
string first = "5";
string second = "7";
int sum = int.Parse(first) + int.Parse(second);
Console.WriteLine(sum);
```
Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden. Når du kjører koden, skal utdataene vise en sum av de to verdiene:
```
12
```
Tar du et minutt å prøve å oppdage det potensielle problemet med det forrige kodeeksemplet? Hva om en av variablene first eller second er satt til verdier som ikke kan konverteres til en int? Det oppstod et unntak under kjøring. C#-kompilatoren og kjøretiden forventer at du planlegger fremover og forhindrer «ulovlige» konverteringer. Du kan redusere kjøretidsunntaket på flere måter.

Den enkleste måten å redusere denne situasjonen på, er å bruke TryParse(), som er en bedre versjon av Parse() metoden.

Konvertere en `string` til en `int` bruker av `Convert` klassen

Klassen Convert har mange hjelpemetoder for å konvertere en verdi fra én type til en annen. I det følgende kodeeksemplet konverterer du et par strenger til verdier av typen int.

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:

string value1 = "5";
string value2 = "7";
int result = Convert.ToInt32(value1) * Convert.ToInt32(value2);
Console.WriteLine(result);

Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden.

Du skal se følgende utdata:
```
35
```
Merk deg

Hvorfor er metodenavnet ToInt32()? Hvorfor ikke ToInt()? System.Int32 er navnet på den underliggende datatypen i .NET-klassebiblioteket som C#-programmeringsspråket tilordner til nøkkelordet int. Convert Fordi klassen også er en del av .NET-klassebiblioteket, kalles den med sitt fulle navn, ikke C#-navnet. Ved å definere datatyper som en del av .NET-klassebiblioteket, kan flere .NET-språk som Visual Basic, F#, IronPython og andre dele de samme datatypene og de samme klassene i .NET-klassebiblioteket.

Metoden ToInt32() har 19 overbelastede versjoner, slik at den kan godta nesten alle datatyper.

du brukte Convert.ToInt32() metoden med en streng her, men du bør sannsynligvis bruke TryParse() når det er mulig.

Så, når skal du bruke Convert klassen? Klassen Convert er best for å konvertere brøktall til heltall (int) fordi den runder opp slik du forventer.

Sammenligne casting og konvertere en til en `decimalint`

Følgende eksempel viser hva som skjer når du prøver å kaste en decimal inn i en int (en innsnevringskonvertering) kontra å bruke Convert.ToInt32() metoden til å konvertere det samme decimal til en int.

Slett eller bruk linjekommentaroperatoren // til å kommentere koden fra forrige øvelsestrinn, og legg til følgende kode:

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

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

Lagre kodefilen, og bruk deretter Visual Studio Code til å kjøre koden.

Du skal se følgende utdata:
```
1
2
```

Avkorting av avkortinger og konvertering av runder

Når du kaster int value = (int)1.5m;, avkortes verdien for flyten slik at resultatet er 1det, noe som betyr at verdien etter desimaltegnet ignoreres fullstendig. Du kan endre litteral flyt til 1.999m og resultatet av støping ville være det samme.

Når du konverterer ved hjelp av Convert.ToInt32(), blir litteral flytverdien riktig avrundet opp til 2. Hvis du endret litteralverdien til 1.499m, blir den avrundet ned til 1.

Sammendrag

Du har dekket flere viktige begreper for datakonvertering og støping:

Forhindre en kjøretidsfeil under utføring av en datakonvertering
Utfør en eksplisitt avstøpning for å fortelle kompilatoren at du forstår risikoen for å miste data
Stol på at kompilatoren utfører en implisitt avstøpning når du utfører en voksende konvertering
Bruk cast-operatoren () og datatypen til å utføre en avstøpning (for eksempel (int)myDecimal)
Convert Bruk klassen når du vil utføre en innsnevringskonvertering, men vil utføre avrunding, ikke en avkorting av informasjon

Tilbakemeldinger

Var denne siden nyttig?

Øvelse – Utforsk støping og konvertering av datatype

Kontroller kunnskapene dine

Tilbakemeldinger