Cada vez que hacemos una aplicación una de nuestras principales labores es darle formato a los datos, para que la aplicación saque las cosas por pantalla como lo debe hacer. Porque una aplicación tiene que ser bonita y tener una interfaz de usuario agradable, y esto, muchas veces, puede resultar un problema para el programador. C# nos provee muchas técnicas para evitarnos un dolor de cabeza, muy sencillas de usar.
Los métodos ToString() y Parse()
Seguramente los conozcas y los usases en el pasado. Veamos:
bool booleanvariable = true; string stringvariable = booleanvariable.ToString();
El método ToString simplemente convierte una variable de cualquier tipo en un objeto del tipo String. En el ejemplo anterior asignamos el valor true a la variable booleanvariable y inmediatamente después llamamos al método ToString sobre esa variable. Lo que obtenemos es un string que contiene la cadena «True».
string stringvar = "false"; bool boolvar = bool.Parse(stringvar);
Utilizamos el método Parse, el String stringvar que contiene false será parseado a la variable booleana boolvar. Sin embargo Parse es unsafe, y puede derivar en una excepción dependiendo del argumento que le entre. A modo de ejemplo, el siguiente código produciría una excepción FormatException:
string stringvar = "fasel"; bool boolvar = bool.Parse(stringvar);
Podemos solventarlo muy fácilmente utilizando el método Tryparse que nos devolverá un valor booleano en función de si la conversión fue exitosa:
string stringvar = "fasel";
bool boolvar = false;
if (!bool.TryParse(stringvar, out boolvar))
{
boolvar = false; // Valor por defecto
}
Sin embargo, aunque todo parece ahora perfecto, nos encontramos con un pequeño problema. El problema es que no podemos distinguir mediante la variable si la conversión ha sido correcta o incorrecta. Para ello usaremos un nullable bool, que nos permitirá no asignar la variable ni a true ni a false, si no a null.
string stringvar = "fasel";
bool? boolvar = null;
bool result;
if (!bool.TryParse(stringvar, out result))
{
boolvar = null; // Valor por defecto
}
else
{
boolvar = (bool)result;
}
El uso de los nullable es muy controvertido, hasta el punto que mucha gente desaconseja su uso. En este ejemplo, si la conversión no fue buena (que no lo fue) boolvar será null, mientras que si fue buena, boolvar tomará el valor de la conversión. Hay que tener en cuenta que esto hace el código más complejo, ya que a partir de ahora tendremos que preocuparnos de si boolvar contiene null o por el contrario está inicializada, y esto no es agradable.
bool x = (bool)boolvar; bool y = boolvar.Value;
En estos dos casos, el compilador deja pasar como bueno el código, sin embargo, si boolvar, siendo un nullable int, contiene null, se producirá una Excepción InvalidOperationException en tiempo de ejecución. Si aún sabiendo la complejidad que pueden aportar los nullables al mantenimiento del código queremos seguir usándolos, una buena manera es haciendo las asignaciones de la siguiente manera:
bool x = boolvar ?? false;
En este caso la variable x cogería false si boolvar contiene null, sería algo así como el valor por defecto. Si no es null cogería el valor de boolvar. Pero la pregunta del millón es ¿Nos acordaremos de hacerlo cada vez que tengamos que trabajar con el valor de boolvar?
Segunda (y última parte) | Conversión de Datos en C# (II): ToString y Format Providers
