C# Type støping

C# er et følsomt språk. I C#, når vi trenger å lagre dataene av en type i en annen type variabel, gir det oss en feil med å si at vi trenger å skrive den variabelen. Variabelenes type endres gjennom støping av type. Når vi erklærer en variabel, tildeler vi den en type som vi senere endrer til den typen vi trenger. Type støping er veldig nyttig når vi må lagre resultatet i en annen type variabel. Type casting har to tilnærminger - den ene er kompilatoren gjør det automatisk, og den andre er det programmereren må gjøre.

Metoder for støping av type

Type støping har to metoder som vi vil dekke detaljert med eksempler:

Implisitt støping av type

I implisitt typecasting konverterer vi de mindre typene til større typer. Som i den "doble" datatypen, tildeler vi en heltallverdi. Den implisitte typen støping gjøres av kompilatoren, og det er en automatisk metode som maskinen gjør. De mindre og større typene er kategorisert basert på antall byte de reserverer mens de er i minnetildeling.

char, int, lang, float, dobbelt

Kompilatoren kan skrive "røye" til "int" og så videre. Den større datatypen kan lagre de mindre.

Eksplisitt støping av type

I eksplisitt typecasting tildeler vi den større typen til den mindre typen. Vi må gjøre denne typekastingen manuelt. I denne typen støping lagrer den mindre typen resultatet av de større typene. Ordensekvensen er som følger:

dobbel, float, lang, int, røye

Den "doble" datatypen er den større. For å lagre "dobbelt" i "int", vil vi gjøre en eksplisitt støping.

Syntaks:

(to_type) var_0;

Attributtet “to_type” er den typen vi ønsker å endre variabelen og runde den med parenteser. "Var_0" er navnet på variabelen hvis typen vi vil endre. Ved å bruke syntaks, la oss endre typen variabel som (float) var_0. La oss si: "Var_0" er en "heltall" -variabel, og vi endrer den til "Float" ved å gjøre sin type casting med (Float).

Innebygde metoder

Type støping kan oppnås ved å bruke de innebygde teknikkene til C#. Den innebygde metoden som er konvertert.Totype_name () brukes. Her er "type_name" navnet på datatypen vi ønsker for en variabel. Skriv navnet på den variabelen i parentesen som konvertering.ToString (var_2). Den konverterer “var_2” til en “streng” -type.

Eksempel 1:

I dette eksemplet vil vi lære om den implisitte typekastingen som selve kompliseringen gjør det. Vi vil skrive de mindre typene til større typer.

ved hjelp av system;
Klasseprogram_1

statisk tomrom main ()
int verdi_0 = 76;
Float Value_1 = 78.9f;
dobbel verdi_2 = verdi_1;
lang verdi_3 = verdi_0;
Konsoll.WritLine ("Implisitt type støping fra float til dobbel"+ verdi_2);
Konsoll.WritLine ("Implisitt type casting fra int til lang"+ verdi_3);

Erklæringen om ett heltallstypevariabel og ett flytende punktvariabel gjøres i den første uttalelsen av koden. Initialiser deretter to variabler til - den ene har en "dobbel" type og den andre har en "lang" type. Her ønsker vi å endre typen "float" til "doble". Det gjøres av kompilatoren. Vi lagrer bare variabelnavnet som har en "float" -type i "dobbelt" -variabelen som "dobbel verdi_2 = verdi_1". "Value_1" -variabelen har en "float" -type og er en mindre type. "Value_2" har en "dobbel" type, og den er den større typen. Vi lagrer bare flyteverdien i "dobbelt" -variabelen. Kompilatoren konverterer den til doble. I neste uttalelse tildeler vi variabelnavnet som har en "heltall" datatype til den "lange" variabelen. Derfor gjør kompilatoren en implisitt avstøpning av heltall til lang tid. Neste, vis både variablene, "dobbelt" -typen og den "lange" typen med en melding ved å bruke konsollen.WritLine () -metode. Her sammenkobler vi meldingen og variabelen for å representere resultatet på konsollen.

Eksempel 2:

Her modifiserer vi variabel -typen ved eksplisitt typecasting.

ved hjelp av system;
Klasseprogram_2

statisk tomrom main ()
float var_1 = 45.333f;
int var_2 = (int) var_1;
dobbel var_3 = 77777.654336;
float var_4 = (float) var_3;
Konsoll.WritLine ("Eksplisitt type casting fra float til int"+ var_2);
Konsoll.WritLine ("Eksplisitt type casting fra dobbelt til float"+ var_4);

La oss initialisere fire forskjellige variabler. Den første variabelen “var_1” har en float -datatype. Den andre tilhører en heltalltype. Her tilordner vi float -typen variabel “var_1” til heltallstypevariabelen “var_2”, og dette gjøres av eksplisitt type casting. Skriv den typen vi ønsker å bruke parentesen, (int) var_1. Dette viser at vi ønsker å endre typen "var_1" som et heltall. Den tredje variabelen av datatype ”dobbel” erklært og en flytende punktverdi er tilordnet den. Videre brukes den eksplisitte typen støping på "var_4". Den fjerde variabelen viser meldingen og verdiene på konsollen med bruk av konsoll.WritLine (). "Float" -verdien endres til "heltall" ved å få verdien før desimaldelen. Og verdien av "dobbelt" oppdateres til "Float" -verdien etter støping av type. Det representerer den første delen før desimalpunktet og bare to desimalpunktverdier etter avrunding.

Eksempel 3:

Denne koden forklarer typekasting av variabelen ved å bruke de innebygde metodene i C#.

ved hjelp av system;
Klasseprogram_3

statisk tomrom main ()
flyteverdi_0 = 25.764f;
Konsoll.WritLine ("From Float to Byte"+ Convert.Tobyte (verdi_0));
Konsoll.WritLine ("From Float to String"+ konverter.ToString (verdi_0));
Konsoll.WritLine ("Fra Float to Double"+ konverter.Todouble (verdi_0));
Konsoll.WritLine ("From Float to Boolean"+ Convert.Toboolsk (verdi_0));
Konsoll.WritLine ("From Float to Decimal"+ Convert.TODECIMAL (verdi_0));
Konsoll.WritLine ("Fra Float to Int"+ konverter.Toint32 (verdi_0));

Først må du erklære en floatvariabel og initialisere den med en flytende punktverdi. Bruk deretter konsollen.WritLine () -funksjon for å vise teksten og de konverterte verdiene. Innen denne funksjonen, ved å ringe konvertitt.Tobyte (verdi_0), konverterer den "float" -verdien til "byte" etter å ha avrundet den av. ToString () konverterer den nødvendige datatypen til “String” uten å endre noe. Den lagrer verdien som en streng. Todouble () -metoden chanegs "Float" -typen til "dobbelt" -typen. Konverter deretter "float" til "boolsk", "desimal" og "heltall". Vi bruker toboolske (), TODECIMAL () og TOINT32 () -metodene. Vi kan endre datatypen til hvilken som helst variabel ved bruk av disse innebygde funksjonene.

Konklusjon

Vi diskuterte hvordan du gjør typekasting på C# språk. Endring av typen variabel er kjent som støping av type. Det er to teknikker for typekasting - den ene er implisitt type støping der kompilatoren automatisk endrer datatypen, og den andre er eksplisitt avstøping som vi gjør manuelt. Den eksplisitte typen støping har to metodologier: en er ved å nevne datatypen i parentes og plassere den før variabelen hvis type vi vil endre. Den andre er å bruke de innebygde funksjonene som brukes for å endre typen variabler. Artikkelen forklarer alt om typekasting med praktiske eksempler.