Type conversies. Conversie van gegevenstypen

Bij het programmeren is het vaak nodig om berekeningen uit te voeren op variabelen van het ene type, en als resultaat een ander type te verkrijgen. Als u bijvoorbeeld gehele getallen deelt, krijgt u een reëel getal. Wanneer een waarde van het ene type wordt opgeslagen in een variabele van een ander type, wordt een gegevenstypeconversie uitgevoerd. In C# wordt dit via verschillende mechanismen geïmplementeerd.

Impliciete conversie van gegevenstypen

Een impliciete conversie vindt plaats wanneer een waarde wordt opgeslagen in een variabele van een ander type zonder dat deze in de code is gespecificeerd.

Als de C#-compiler een gegevenstype automatisch wil converteren, moeten er twee voorwaarden vervuld zijn:

• Het waardetype en het variabeletype moeten compatibel zijn met elkaar;
• Het bereik van mogelijke waarden van een variabel type mag niet kleiner zijn dan dat van een waardetype.

Byte a = 15; byte b = 120; int c = a + b;

IN in dit voorbeeld rennen impliciete conversie , en variabele c zal uiteindelijk van het type int zijn. Dit is mogelijk omdat byte en int gehele getallen zijn, en het int-type het bytebereik volledig omvat.

Nog een voorbeeld:

Kort a = 815; ukort b = a;//Fout

Ook al ligt het nummer 815 in dit geval binnen het ukorte bereik er verschijnt een foutmelding. Dit komt door het feit dat de compiler voor expliciete conversie controleert alleen de bovenstaande voorwaarden en kijkt alleen naar typen, zonder aandacht te besteden aan specifieke waarden.

Expliciete conversie van gegevenstypen

Als niet aan de voorwaarden voor een impliciete conversie wordt voldaan, maar er wel een typeconversie moet worden uitgevoerd, wordt er gebruik gemaakt van een typecast. Dit is een indicatie doeltype, waarin het berekeningsresultaat, dat tussen haakjes vóór de uitdrukking staat, moet worden omgezet.

Int d = 13; int c = 4; var e = (dubbel)d/c;

Dus de variabele e krijgt typ dubbel en de waarde is 3,25. Als we geen conversie zouden gebruiken, zou deze variabele een int-type en een waarde van 3 hebben volgens de regels voor het delen van gehele getallen in C#.

Nog een voorbeeld:

Ukort getal = 257; dubbele dbl = 34,9318; int rnd = (kort) dbl; // Krijgt de waarde 34 byte what = (byte) num; // Krijgt de waarde 1 toegewezen

In het geval van rnd, wordt geëxecuteerd volgende regel: Bij het converteren van getallen met drijvende komma naar gehele getallen, wordt hun fractioneel deel weggegooid.

En in het geval van wat alles is een beetje ingewikkelder. Bij het uitvoeren van een expliciete conversie let de compiler niet op typebereiken. En tijdens de uitvoering van het programma, als er een poging wordt gedaan om binnen te komen variabele waarde, die zich niet binnen zijn bereik bevindt (met een hogere bitdiepte), worden alle bits van hoge orde gewist. Nummer 257 inch binaire representatie type ushort ziet eruit als 00000001 00000001. Bij conversie naar byte blijft alleen de laatste byte 00000000, dat wil zeggen 1, over.

Een conversie waarbij het bereik van het variabeletype het bereik van het waardetype niet volledig dekt, wordt een vernauwingsconversie genoemd. Om gegevensverlies te voorkomen, zoals in het vorige voorbeeld, moet u een overloopcontrole gebruiken.

Het beperken van de overstroom van gegevensconversies

Het is duidelijk dat u plaatsen in de code waar gegevensverlies als gevolg van overflow kan optreden, niet kunt negeren. Anders kunnen variabelen onverwachte waarden aannemen, wat de werking van het programma zal beïnvloeden, en de oorzaak van de fout zal vrij moeilijk te achterhalen zijn.

Standaard wordt het optreden van een overloop genegeerd. Om er zeker van te zijn dat er in dit geval een passende uitzondering wordt gegenereerd, wordt het gecontroleerde sleutelwoord gebruikt. Het kan vóór een bepaalde uitdrukking worden geplaatst of om er een codeblok mee aan te duiden. Als er vervolgens een uitzondering optreedt, kan deze met de constructie worden afgehandeld proberen en vangen.

Willekeurig rnd = nieuw Willekeurig(); int groter = rnd.Volgende(99999); // Genereert een willekeurig getal van 0 tot 99999, maar kleiner; try ( kleiner = gecontroleerd((kort) groter); ) catch (System.OverflowException e) ( Console.WriteLine('Overflow verhoogd door gecontroleerd op kleiner: ' + e.ToString()); // Prints //een bericht over dat een uitzondering werd afgehandeld kleiner = -1;

groter is willekeurig nummer van 0 tot 99999. Als deze waarde het bereik van het korte type overschrijdt, wordt er een uitzondering verwerkt System.OverflowException en variabel kleiner krijgt de waarde -1 toegewezen. Als er geen overflow optreedt, is er geen uitzondering en neemt de kleinere variabele eenvoudigweg de waarde aan van de grotere variabele, maar dan in het type kort.

is exploitant

Om te controleren of een object in C# naar een bepaald type gecast kan worden, wordt de operator gebruikt is. Het controleert of een object een instantie is van het opgegeven type zelf of een afgeleide ervan. Het resultaat van een binaire bewerking met de operator is is Booleaanse waarde(waar of onwaar).

Een voorbeeld van het gebruik van de operator is:

Klasse Samle1 () klasse Samle2 () : Sample1 () // Erft klasse Sample1 klasse Sample3 () Samle1 t1 = new Samle1(); Monster2 t2 = nieuw Monster2(); Voorbeeld3 t3 = nieuw Voorbeeld3(); teken t4 = 't'; if (t1 is Sample1) ( Console.WriteLine(“t1 is Sample1”); ) // Wordt afgedrukt if (t2 is Sample1) ( Console.WriteLine(“t2 is Sample1”); ) // Wordt afgedrukt if ( t3 is Sample1) ( Console.WriteLine(“t3 is Sample1”); ) // Wordt niet afgedrukt als (t4 is Sample1) ( Console.WriteLine(“t4 is Sample1”); ) // Wordt niet afgedrukt

Exploitant als

De operator as wordt gebruikt om compatibele referentietypen te converteren. Opgemerkt moet worden dat als de conversie niet mogelijk is, er geen uitzondering wordt gegenereerd, maar wordt geretourneerd nulwaarde. Hiermee moet rekening worden gehouden bij het verwerken van het resultaat van de conversie met behulp van as.

Klasse SamleClass() object Arr = nieuw object; Arr = nieuwe VoorbeeldKlasse(); Arr = “welkom”; Arr = (kort) 654; Arr = nul; voor (byte i = 0; i< Arr.Length; i++) { string t1 = Arr[i] as string; SampleClass t2 = Arr[i] as SampleClass; if (t1 != null) { Console.WriteLine(“{0}: it’s a string ‘” + t1 + “’”, i+1); } else if (t2 != null) { Console.WriteLine(“{0}: it’s a SampleClass”, i+1); } else { Console.WriteLine(“{0}: it’s not string or SampleClass”, i+1); } }

De uitvoer van het voorbeeld zou als volgt zijn:

1: het is een SampleClass

2: het is een string "welkom"

3: het is geen string of SampleClass

4: het is geen string of SampleClass

Typen converteren met behulp van de Convert-klasse

De systeemklasse System.Convert bevat methoden die kunnen worden gebruikt om waarden te converteren basistypen gegevens, evenals systeemtype DatumTijd.

Overzetten bevat een reeks methoden zoals ToType, waarbij Type wordt vervangen door de systeemnaam van het doelwaardetype (bijvoorbeeld ToChar, ToInt32, ToBoolean). Met deze methoden kunt u alle mogelijke conversies uitvoeren vanuit standaard C#-typen.

De Convert.ChangeType-methode converteert elk object naar elk opgegeven type. Als er sprake is van een type-mismatch of overflow, genereert de methode een uitzondering.

Laten we verder gaan met voorbeelden. Klas Testen, met voorbeelden, is een reeks gegevens van verschillende typen waarop bewerkingen worden uitgevoerd die typeconversies illustreren. Hier is de klassebeschrijving

Testen: systeem gebruiken;
naamruimte TypesProject
{
openbare klasse testen{
/// < samenvatting>
/// een reeks scalaire velden van verschillende typen.
///
privébyte b= 255;
privé int x= 11 ;
privé uint ux= 1111 ;
privé vlotter= 5,5f;
privé dubbele dy= 5.55;
privéreeks s= "Hallo!";
privéreeks si= "25";
privé object obj= nieuw object();
// Hierna volgen de klassenmethoden, die onderweg worden vermeld
// beschrijvingen van voorbeelden
}
}

De klassegegevensset omvat scalaire gegevens van het rekenkundige type, gerelateerd aan waardetypen, variabelen van het tekenreekstype en type voorwerp, behorend tot referentietypen. Overweeg een gesloten (privé) methode van deze klasse - procedure Wie is wie met een formeel klassenargument Voorwerp. De procedure toont aan de console de naam van het argument dat eraan is doorgegeven, het type en de waarde ervan.

Hier is haar tekst:

/// < samenvatting>
/// De methode geeft informatie weer over het type en
/// de waarde van het daadwerkelijke argument. Formeel
/// argument heeft typevoorwerp. Feitelijke argumentatie
/// kan van elk type zijn, omdat dit altijd het geval is
/// impliciete conversie naar type is toegestaanvoorwerp.
///
/// Naamsecondeargument
/// Laten we zeggenargumentelktype
private void WhoIsWho(tekenreeksnaam, object willekeurig){
Console.WriteLine("type{0} is (1), waarde is{2}",
naam, any.GetType(), any.ToString());
}

Hier is een openstaande (publiek) klasse methode Testen, waarin de methode herhaaldelijk wordt aangeroepen Wie is wie met argumenten van verschillende typen:

/// < samenvatting>
/// krijg informatie over het type en de waarde
/// doorgegeven argument - variabele of expressie
/// samenvatting>
publieke leegte WhoTest(){
WholsWie("x", x);
WholsWho("ux", ux);
WieIsWie("y", y);
WieIsWie("dy", dy);
WieIsWie("s", s);
WieIsWie("11+ 5.55 + 5,5f", 11+ 5.55 + 5,5f);
obj= 11 + 5.55 + 5,5f;
WieIsWie(" obj", obj);
}

Merk op dat de entiteit elk- formeel klassenargument Voorwerp, die bij elke aanroep dynamisch het type verandert door te binden aan het object dat is opgegeven door het feitelijke argument. Daarom is het argumenttype dat naar de console wordt afgedrukt, het type van het daadwerkelijke argument. Merk ook op dat het van de klas is geërfd Voorwerp methode GetType retourneert het FCL-type, dat wil zeggen het type waarnaar het taaltype wordt weerspiegeld en waarmee het feitelijk wordt gebruikt werk in uitvoering bij het uitvoeren van de module. Bij de meeste oproepen is het feitelijke argument een variabele: de overeenkomstige klasse-eigenschap Testen, maar in één geval het gebruikelijke rekenkundige uitdrukking, automatisch geconverteerd naar een object. Een soortgelijke situatie doet zich voor bij het uitvoeren van een opdracht in de onderhavige procedure.

In afb. Figuur 11 toont de console-uitvoer die wordt verkregen bij het aanroepen van de methode WieTest in de bovenstaande procedure Voornaamst klas Klassiek.

Figuur 11. WhoTest-testresultaten afdrukken

Waar, hoe en wanneer worden typeconversies uitgevoerd?

De behoefte aan typeconversie ontstaat bij expressies, toewijzingen en vervanging van formele methodeargumenten door daadwerkelijke argumenten.

Als bij het evalueren van een expressie de operanden van de bewerking verschillende typen hebben, wordt het noodzakelijk om ze naar hetzelfde type te casten. Deze behoefte doet zich ook voor als de operanden van hetzelfde type zijn, maar niet consistent zijn met het type bewerking. Bij het uitvoeren van optellingen bijvoorbeeld operanden van het type byte moet naar type worden gegoten int, aangezien optelling niet via bytes wordt gedefinieerd. Bij het uitvoeren van een opdracht X= e brontype e en doeltype X moet worden overeengekomen. Op dezelfde manier moeten bij het aanroepen van een methode ook de typen bron en doel (de feitelijke en formele argumenten) consistent zijn.

Referentietypeconversies

Omdat bewerkingen op referentietypen niet zijn gedefinieerd (de uitzondering zijn tekenreeksen, maar bewerkingen daarop, inclusief toewijzing, worden uitgevoerd zoals op waardetypen), ontstaat de noodzaak daarvoor alleen tijdens toewijzingen en methodeaanroepen.

Typ Conversies in Expressies

In C# zijn dergelijke conversies onderverdeeld in impliciet en expliciet. Impliciete transformaties omvatten die transformaties waarvan het resultaat altijd succesvol is en niet leidt tot verlies van de nauwkeurigheid van de gegevens. Impliciete conversies worden automatisch uitgevoerd. Voor rekenkundige gegevens betekent dit dat bij impliciete conversies het bereik van het bestemmingstype het bereik bevat originele soort. Bijvoorbeeld conversie van type byte van soort int verwijst naar impliciet omdat het bereik van het type is byte is een subset van het bereik int. Deze conversie is altijd succesvol en kan niet leiden tot verlies van nauwkeurigheid.

Expliciete conversies omvatten toegestane conversies waarvan het succes niet gegarandeerd is of kan leiden tot verlies van nauwkeurigheid. Dergelijke potentieel gevaarlijke transformaties moeten expliciet door de programmeur worden gespecificeerd. Conversie van type int van soort byte is expliciet omdat het onveilig is en ertoe kan leiden dat aanzienlijke cijfers verloren gaan. Houd er rekening mee dat niet alle typen expliciete conversies hebben. In dit geval zijn andere typen conversiemechanismen vereist, die later zullen worden besproken.

Conversies binnen een rekenkundig type

Het rekenkundige type, zoals weergegeven in de gegevenstypetabel, is verdeeld in 11 subtypen. In afb. Figuur 12 toont een diagram van transformaties binnen een rekenkundig type.

Figuur 12. Hiërarchie van conversies binnen een rekenkundig type

Met het diagram in de afbeelding kunt u de reeks beantwoorden belangrijke kwesties gerelateerd aan het bestaan ​​van transformaties tussen typen. Als het diagram een ​​pad (pijlen) toont van type A naar type B, betekent dit dat er sprake is van een impliciete conversie van type A naar type B. Alle andere conversies tussen subtypen van het rekenkundige type bestaan, maar zijn expliciet. Merk op dat er geen cycli in het diagram voorkomen, alle pijlen zijn eenrichtingsverkeer, dus de conversie terug naar de impliciete moet altijd expliciet worden gespecificeerd.

Het in het diagram aangegeven pad kan behoorlijk lang zijn, maar dit betekent niet dat de hele reeks transformaties wordt uitgevoerd dit pad. De aanwezigheid van een pad duidt alleen op het bestaan ​​van een impliciete conversie, en de conversie zelf wordt slechts één keer uitgevoerd, van brontype A naar bestemmingstype B.

Soms doet zich een situatie voor waarin voor één brontype meerdere typen bestemmingen tegelijk kunnen bestaan ​​en het nodig is een doel te selecteren: het bestemmingstype. Dergelijke selectieproblemen ontstaan ​​bijvoorbeeld bij het werken met overbelaste methoden in klassen.

De regel voor het selecteren van een implementatie bij het aanroepen van een methode is als volgt: selecteer de implementatie waarvoor het in het diagram gespecificeerde transformatiepad korter is. Als er een exacte match is van de parameters per type (pad met lengte 0), dan zal uiteraard deze specifieke implementatie worden geselecteerd.

Laten we eens naar een ander testvoorbeeld kijken. Naar de klas Testen omvatte een groep overbelaste methoden OLaden met één en twee argumenten. Dit zijn de methoden:

/// < samenvatting>
/// Groep overbelaste methodenOLaden
/// met een of twee argumenten van het rekenkundige type.
/// Als er slechts één feitelijk argument is, wordt een van de volgende aangeroepen
/// methoden die het meest overeenkomen met het argumenttype.
/// Als u een methode met twee argumenten aanroept, is dit mogelijk
/// conflict bij het kiezen van de juiste methode, leidend tot
/// naar een compileerfout.
///
private void OLoad(float par){
Console.WriteLine("zwevende waarde{0}", par);
}
/// < samenvatting>
/// Overbelaste methodeOLadenmet één typeparameterlang
///
///
private void OLoad(lange par){
Console.WriteLine("lange waarde (0)", par);
}
/// < samenvatting>
/// Overbelaste methodeBijladenmet één typeparameterlang
///
///
private void OLoad(ulong par){
Console.WriteLine("ulong-waarde (0)", par);
}
/// < samenvatting>
/// Overbelaste methodeOLadenmet één typeparameterdubbele
///
///
privé leegte OnLoad (dubbele par){
Console.WriteLine("dubbele waarde (0)", par);
}
/// < samenvatting>
/// Overbelaste methodeOLadenmet twee typeparameterslangEnlang
///
///
///
private void OLoad(lange par1, lange par2){
Console.WriteLine("lange par1{0}, lange par2{1}", par1, par2);
}
/// < samenvatting>
/// Overbelaste methodeOLadenmet twee typeparameters
/// dubbeleEndubbele
///
///
///
private void OLoad(dubbele par1, dubbele par2){
Console.WriteLine("dubbele par1{0}, dubbele par2{1}", par1, par2);
}
/// < samenvatting>
/// Overbelaste methodeOLadenmet twee typeparameters
/// intEnvlot
///
///
///
private void OLoad(int par1, float par2){
Console.WriteLine("int par1{0}, vlotter par2{1}", par1, par2);
}

Al deze methoden zijn vrij eenvoudig. Ze rapporteren informatie over het type en de betekenis van de doorgegeven argumenten.

Hier is de testprocedure die de methode aanroept OLaden met verschillende aantallen en soorten argumenten:

/// < samenvatting>
/// Een overbelaste methode aanroepenOLaden. Afhankelijk van
/// het type en aantal argumenten dat een van de groepsmethoden wordt aangeroepen.
///
publieke leegte OLoadTest(){
OLaden(x);
OLaden(ux);
OLaden(y);
OLaden(dy);
// OLaden(x,ux);
// conflict: (int, zwevend)En(lang, lang)
OLoad(x, (zwevend) ux);
OLaden(y, dy);
OLaden(X, dy);
}

Houd er rekening mee dat een van de oproepen wordt becommentarieerd omdat deze in de uitzendfase tot een conflict leidt. Om het conflict bij het aanroepen van de methode op te lossen, was het nodig om een ​​expliciete argumentconversie op te geven, die wordt weergegeven in de regel na de commentaarregel. Testresultaat OLaadTest getoond in afb. 13.

Figuur 13. OLoadTest-testresultaten afdrukken

Expliciete conversies

Zoals reeds besproken kunnen expliciete conversies gevaarlijk zijn vanwege het verlies aan nauwkeurigheid. Daarom worden ze uitgevoerd onder leiding van de programmeur - hij draagt ​​de volledige verantwoordelijkheid voor de resultaten.

Conversies van tekenreekstypes

Een belangrijke klasse van conversies zijn conversies naar het stringtype en omgekeerd. Conversies naar het stringtype worden altijd gedefinieerd omdat alle typen afstammelingen zijn van de basisklasse Voorwerp, en daarom een ​​methode hebben NaarString(). Voor ingebouwde typen is een geschikte implementatie van deze methode gedefinieerd. In het bijzonder, voor alle subtypen van het rekenkundige type, de methode NaarString() retourneert een tekenreeks in een geschikte vorm die de corresponderende waarde van het rekenkundige type specificeert. Merk op dat de methode NaarString kan expliciet worden aangeroepen, maar als een expliciete aanroep niet is gespecificeerd, zal deze impliciet worden aangeroepen wanneer de context een conversie naar een stringtype vereist. Hier is een relevant voorbeeld:

/// < samenvatting>
/// Demonstratie van conversie naar een reeks gegevens van verschillende typen.
///
publieke leegte ToStringTest()
{
S= " VladimirPetrov ";
s1= " Leeftijd: ";
ux= 27;
S= S+ s1+ ux.ToString();
s1= " Salaris: ";
dy= 2700.50;
S= S+ s1+ dy;
WieIsWie(" S", S);
}

Het resultaat van deze procedure wordt getoond in Fig. 14.

Figuur 14. De resultaten van de ToStringTest-test afdrukken

Conversies van het stringtype naar andere typen, zoals rekenkunde, moeten expliciet worden uitgevoerd. Maar er zijn geen expliciete conversies tussen rekenkunde en strings. Er zijn andere mechanismen nodig, en C# heeft die. Voor dit doel kunt u de overeenkomstige klassenmethoden gebruiken Overzetten FCL-bibliotheek ingebouwd in de naamruimte Systeem. Laten we een overeenkomstig voorbeeld geven:

/// < samenvatting>
/// Demonstratie van het converteren van een string naar verschillende gegevenstypen.
///
publieke leegte FromStringTest(){
S= " Binnenkomenleeftijd ";
Console.WriteLine(s);
s1= Console.ReadLine();
ux= Convert.ToUInt32(s1);
WieIsWie("Leeftijd: ",ux);
S= "Voer salaris in";
Console.WriteLine(s);
s1= Console.ReadLine();
dy= Convert.ToDouble(s1);
WieIsWie("Salaris: ", dy);
}

Dit voorbeeld demonstreert console-invoer verschillende soorten. Gegevens gelezen van de console met behulp van de methode Leesregel of Lezen, zijn altijd een string, die vervolgens naar het gewenste type moet worden geconverteerd. Om dit te doen, roept u de overeenkomstige klassenmethoden aan Overzetten. Om de conversie te laten slagen, moet de string uiteraard een waarde bevatten in een formaat dat een dergelijke conversie mogelijk maakt. Merk bijvoorbeeld op dat bij het schrijven van de waarde van een getal een komma en geen punt moet worden gebruikt om het breukgedeelte te markeren; anders zal er een runtimefout optreden.

In afb. Figuur 15 toont de resultaten van uitvoer en invoer van gegevens vanaf de console wanneer deze procedure wordt uitgevoerd.

Figuur 15. De resultaten van de FromStringTest-test afdrukken