Gegevenstypes in C# en hoe ze te converteren
Inleiding
Gegevenstypes in C#? Hoe saai kunnen we het maken. Desalniettemin toch erg belangrijk en de Ariane V raket is daar een goed voorbeeld van. Men moest de raket tot ontploffing brengen omdat de raket van haar koers begon af te wijken. Uit nader onderzoek bleek dat de koersafwijkingen werden veroorzaakt door het gebruik van een verkeerd gegevenstype door de oriëntatie systemen. Een klein detail met fatale gevolgen voor de Ariane V.
Een programmeertaal zal altijd wel iets moeten doen met data. Je kunt bijvoorbeeld denken aan het uitvoeren van berekeningen waarbij de resultaten ergens worden opgeslagen. En wat je opslaat, dat moet iets zijn van een bepaald gegevenstype. Je kan bijvoorbeeld denken aan een gegevenstype int voor het doen opslaan van getallen.
In deze post volgen (eenvoudige) voorbeelden van gegevenstypes, variabelen en hoe een gegevenstype om te zetten naar een ander gegevenstype. We maken daarbij gebruik van de int.Parse, de Convert.ToInt32 en de TryParse. Ook het Casten komt aan de orde.
strongly typed
C# wordt beschouwd als een “strongly typed” programmeertaal. “Strongly typed” houdt in dat de taal je probeert te dwingen om bepaalde gegevenstypes te gebruiken. Dit alles met het doel om je goed te laten nadenken over de gegevenstypes die je gaat gebruiken. Verder wil men met het strongly typed wezen van een programmeertaal bewerkstelligen dat het omzetten naar een ander gegevenstype altijd volgens vaste regels gaat. De taal blijft dan voorspelbaar in haar doen en laten.
In het volgende voorbeeldprogramma stoppen we de waarde “A” in een variabele stringwaarde en de gegevenstype van die variabele is string:
string stringWaarde = "A";
int intWaarde;
double dblWaarde;
We hebben daarnaast een variabele intWaarde en de gegevenstype van die variabele is int. We kunnen de waarde “A” niet in variabele intWaarde stoppen omdat “A” een letter is en geen getal. Laat ons eens kijken wat er gebeurt als we dat toch proberen te doen.
int.Parse en Convert.ToInt32
We gebruiken int.Parse en Convert.ToInt32 om die variabele intWaarde te vullen met een letter en we krijgen de foutmelding: String was not in a correct format (exception type System.FormatException) . Iets wat wel was te verwachten…
// int.Parse
intWaarde = int.Parse(stringWaarde);
// Convert.ToInt32
intWaarde = Convert.ToInt32(stringWaarde);
Convert.ToInt32 is vergevingsgezind als het gaat om lege waarden (null waarden). Als de input parameter null is dan retourneert Convert.ToInt32 de default waarde 0.
TryParse
“Bezint eer ge begint” en dat “bezinnen” kunnen we doen met TryParse. Met TryParse gaan we eerst kijken of de gegevensconversie sowieso gaat lukken en we krijgen de waarde false als de gegevensconversie niet gaat lukken:
// int.TryParse
if(!int.TryParse(stringWaarde, out intWaarde))
{
Console.WriteLine(
"Gegevensconversie niet mogelijk." +
Environment.NewLine);
}
En we zien dat we de TryParse kunnen afvangen want als het niet lukt dan krijgen we een waarde false. In zo’n geval kunnen we een gebruiker een tweede kans geven door hem / haar opnieuw een waarde in te laten geven. In dit voorbeeld een waarde dat wel in variabele intWaarde gestopt kan worden.
En als TryParse aangeeft dat de gegevensconversie gaat lukken? Dan is het goed en dan zetten we de waarde in de desbetreffende variabele. Veel netter toch? Je krijgt zo geen situaties dat het programma bij elke niet gelukte gegevensconversie meteen gierend uit de bocht vliegt met een foutmelding.
Casten
Van expliciete conversie is sprake als je naar een bepaald gegevenstype converteert en je voor lief neemt dat de conversie gaat leiden tot het verlies van data. In het onderstaande voorbeeldprogramma zie je een toepassing van een expliciete conversie (ook wel casten genoemd): intWaarde = (int)dblWaarde.
// casting explicit conversion
dblWaarde = 1.1;
Console.WriteLine("dblWaarde:" + dblWaarde);
intWaarde = (int)dblWaarde;
Console.WriteLine("intWaarde:" + intWaarde +
Environment.NewLine);
De waarde 1,1 (één- één-tiende) in de double variabele wordt afgekapt tot 1 als de waarde in een int variabele wordt gestopt. De compiler zal geen waarschuwingen geven want je neemt ten slotte voor lief dat data verloren gaat door te casten.
Het is nog steeds van alle tijden. In om het even welke programmeertaal kan nog steeds op een verkeerd moment gecast worden. Je ziet dan dingen over het hoofd en je wordt daar ook niet op gewezen door de compiler. Misschien was zoiets ook gebeurd bij de oriëntatie systemen van de Ariane V.
Slot
Je hebt mijn artikel gelezen en je hebt het gehaald tot dit punt? Dat doet me deugd. Ik ben er zo te zien in geslaagd je aandacht vast te houden tot het einde van dit artikel.
Je zou nu kunnen “Googlen” naar de artikelen van andere auteurs die ook iets hebben geschreven over gegevenstypes in C#. En als je een interessant artikel hebt gevonden dan hoop ik dat mijn artikel je kan helpen in het doorgronden van het artikel van die andere auteur. Ik hoop je weer terug te zijn in de volgende blog post. Wil je weten wat ik nog meer over C# heb geschreven? Hit the C# button…
Voorbeeldprogramma:
using System;
namespace GegevensTypes2
{
class MainClass
{
public static void Main(string[] args)
{
try
{
string stringWaarde = "A";
int intWaarde;
double dblWaarde;
// int.Parse
intWaarde = int.Parse(stringWaarde);
// Convert.ToInt32
intWaarde = Convert.ToInt32(stringWaarde);
// int.TryParse
if(!int.TryParse(stringWaarde, out intWaarde))
{
Console.WriteLine(
"Gegevensconversie niet mogelijk." +
Environment.NewLine);
}
// casting explicit conversion
dblWaarde = 1.1;
Console.WriteLine("dblWaarde:" + dblWaarde);
intWaarde = (int)dblWaarde;
Console.WriteLine("intWaarde:" + intWaarde +
Environment.NewLine);
}
catch(Exception ex)
{
Console.WriteLine("We hebben een exception");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.GetType());
}
}
}
}