Conversión de tipos en C#

Conversión de tipos:

Cuando convertimos de un tipo superior a otro inferior hay riesgo de perdida de información. Por ejemplo un tipo “double” a otro tipo “long“. Para limitar este riesgo el compilador activa un error cuando se encuentra con esta situación. No obstante este tipo de conversión no está prohibida, para poder utilizarla simplemente hacemos una conversión explícita.

double x;
long y;
x = 21.234323;
y = (long) x;
Console.WriteLine ("valor de x:" + x);
Console.WriteLine ("valor de y:" + y);

Conversión hacia una cadena de caracteres:

La función “format” de la clase String permite elegir la forma del resultado de la conversión de un valor cualquiera en una cadena de caracteres. Ésta función espera como primer parámetro una cadena que representa el formato en la cual desea obtener el resultado, el segundo parámetro corresponde al valor que se debe convertir.

  • Valores numéricos
    • Currency: Formato monetario tal como está definido en el sistema.
      • String.Format (“Importe = {0:c}”,12.35);
      • Resultado: 12,35 €
    • Fixed: Al menos un caracter para la parte entera y al menos dos para la parte decimal.
      • String.Format(“{0:f}”,0.2);
      • Resultado: 0,20
    • Percent: Multiplica el valor por 100 y añade el símbolo “%” después.
      • String.Format(“0:p}”,0.2);
      • Resultado: 20,00%
    • Standard: Formato numérico tal como está definido en las opciones regionales y lingüísticas del panel de configuración del sistema.
      • String.Format(“{0:n}”,245813.5862);
      • Resultado: 245.813,59
    • Scientific: Notación científica.
      • String.Format(“{0:c}”,245813.58);
      • Resultado: 2,458136e+005
    • Hexadecimal: Utilizable únicamente para los valores enteros.
      • String.Format(“{0:x}”,245813);
      • Resultado: 3C035

Cadena de formateo personalizada para valores numéricos:

  • 0
    • Reserva una ubicación para un carácter numérico. Los ceros no significativos se visualizan.
    • String.format(“{0:00000000000.0000}”,245813.12);
    • Resultado: 00000245813,1200
  • #
    • Reserva una ubicación para un carácter numérico. Los no significativos no se visualizan.
    • String.format(“0:##########.####”,245813.12);
    • Resultado: 245813,12
  • .
    • Reserva una ubicación para el separador decimal.
  • ,
    • Reserva una ubicación para el separador de millares.

Formatos de fecha y hora

  • G
    • Formato Fecha corta y formato Hora tal como está definido en el sistema
    • String.format(“{0:G}”,DateTime.now);
    • Resultado: 01/12/2013 16:20:13
  • D
    • Formato Fecha larga tal como está definido en las opciones regionales
    • String.format(“{0:D}”,DateTime.now);
    • Resultado: domingo 1 diciembre del 2013
  • d
    • Formato Fecha corta
    • String.format(“{0:d}”,DateTime.now);
    • Resultado: 01/121/2013
  • T
    • Formato Hora
    • String.format(“{0:T}”,DateTime.now);
    • Resultado: 16:28:23
  • s
    • Formato ordenable
    • String.format(“{0:s}”,DateTime.now);
    • Resultado: 2013-12-01T16:29:34
// create date time 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);

String.Format("{0:y yy yyy yyyy}", dt);  // "8 08 008 2008"   year
String.Format("{0:M MM MMM MMMM}", dt);  // "3 03 Mar March"  month
String.Format("{0:d dd ddd dddd}", dt);  // "9 09 Sun Sunday" day
String.Format("{0:h hh H HH}",     dt);  // "4 04 16 16"      hour 12/24
String.Format("{0:m mm}",          dt);  // "5 05"            minute
String.Format("{0:s ss}",          dt);  // "7 07"            second
String.Format("{0:f ff fff ffff}", dt);  // "1 12 123 1230"   sec.fraction
String.Format("{0:F FF FFF FFFF}", dt);  // "1 12 123 123"    without zeroes
String.Format("{0:t tt}",          dt);  // "P PM"            A.M. or P.M.
String.Format("{0:z zz zzz}",      dt);  // "-6 -06 -06:00"   time zone

// month/day numbers without/with leading zeroes
String.Format("{0:M/d/yyyy}", dt);            // "3/9/2008"
String.Format("{0:MM/dd/yyyy}", dt);          // "03/09/2008"

// day/month names
String.Format("{0:ddd, MMM d, yyyy}", dt);    // "Sun, Mar 9, 2008"
String.Format("{0:dddd, MMMM d, yyyy}", dt);  // "Sunday, March 9, 2008"

// two/four digit year
String.Format("{0:MM/dd/yy}", dt);            // "03/09/08"
String.Format("{0:MM/dd/yyyy}", dt);          // "03/09/2008"

String.Format("{0:t}", dt);  // "4:05 PM"                         ShortTime
String.Format("{0:d}", dt);  // "3/9/2008"                        ShortDate
String.Format("{0:T}", dt);  // "4:05:07 PM"                      LongTime
String.Format("{0:D}", dt);  // "Sunday, March 09, 2008"          LongDate
String.Format("{0:f}", dt);  // "Sunday, March 09, 2008 4:05 PM"  LongDate+ShortTime
String.Format("{0:F}", dt);  // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt);  // "3/9/2008 4:05 PM"                ShortDate+ShortTime
String.Format("{0:G}", dt);  // "3/9/2008 4:05:07 PM"             ShortDate+LongTime
String.Format("{0:m}", dt);  // "March 09"                        MonthDay
String.Format("{0:y}", dt);  // "March, 2008"                     YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"   RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"             SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"            UniversalSortableDateTime

Cadena de formateo personalizado para valores de fecha y hora

  • d: Día del mes sin cero no significativo
  • dd: Día del mes con cero no significativo
  • ddd: Nombre del día de la semana abreviado
  • dddd: Nombre del día de la semana completo
  • M: Número del mes sin cero significativo
  • MM: Número del mes con cero no significativo
  • MMM: Nombre del mes abreviado
  • MMMM: Nombre del mes completo
  • h: Hora sin cero no significativo (formato 12H)
  • hh: Hora con cero no significativo (formato 12H)
  • H: Hora sin cero no significativo (formato 24H)
  • HH: Hora con cero no significativo (formato 24H)
  • m: Minuto sin cero no significativo
  • mm: Minuto con cero no significativo
  • s: Segundo sin cero no significativo
  • ss: Segundo con cero no significativo
  • y: Año en una cifra. Si es el único carácter de la cadena de formateo, en este caso se debe utilizar %y
  • yy: Año en dos cifras
  • yyyy: Año en cuatro cifras
  • zzz: Desfase respecto al tiempo universal (GMT).

Conversión desde una cadena de caracteres

La conversión inversa desde una cadena de caracteres hacia un tipo numérico se hace con la función Parse.

float iva = float.Parse("21");

Si la conversión no se realiza correctamente se genera un excepción. Para evitar esto podemos utilizar la función TryParse.

if (float.TryParse("21", out iva)) {
    Console.writeLine("Conversión Ok."); }
else {
    Console.WriteLine("Problema durante la conversión"); }