Procedimiento Convertir una cadena en un número (Guía de programación de C#)
Puede convertir string
en un número si llama al método Parse
o TryParse
que se encuentra en tipos numéricos (int
, long
, double
, etc.), o bien mediante los métodos de la clase System.Convert.
Resulta algo más eficaz y sencillo llamar a un método TryParse
(por ejemplo, int.TryParse("11", out number)
) o un método Parse
(por ejemplo, var number = int.Parse("11")
). El uso de un método Convert resulta más práctico para objetos generales que implementan IConvertible.
Puede usar los métodos Parse
o TryParse
sobre el tipo numérico que espera que contenga la cadena, como el tipo System.Int32. El método Convert.ToInt32 utiliza Parse internamente. El método Parse
devuelve el número convertido; el método TryParse
devuelve un valor booleano que indica si la conversión se realizó correctamente, y devuelve el número convertido en un parámetro out
. Si el formato de la cadena no es válido, Parse
inicia una excepción, pero TryParse
devuelve false
. Cuando se llama a un método Parse
, siempre debe usar control de excepciones para detectar un FormatException cuando se produzca un error en la operación de análisis.
Llamada a métodos Parse o TryParse
Los métodos Parse
y TryParse
no tienen en cuenta los espacios en blanco al principio ni al final de la cadena, pero todos los demás caracteres deben ser caracteres que formen el tipo numérico adecuado (int
, long
, ulong
, float
, decimal
, etc.). Si hay un espacio en blanco dentro de la cadena que forma el número, se producirá un error. Por ejemplo, puede usar el método decimal.TryParse
para analizar "10", "10,3" o " 10 ", pero no para analizar 10 en "10X", "1 0" (fíjese en el espacio insertado), "10 ,3" (fíjese en el espacio insertado) o "10e1" (ahí funciona float.TryParse
), y así sucesivamente. Una cadena cuyo valor es null
o String.Empty no se puede analizar correctamente. Puede buscar una cadena nula o vacía antes de intentar analizarla mediante una llamada al método String.IsNullOrEmpty.
En el siguiente ejemplo se muestran llamadas correctas e incorrectas a Parse
y TryParse
.
using System;
public static class StringConversion
{
public static void Main()
{
string input = String.Empty;
try
{
int result = Int32.Parse(input);
Console.WriteLine(result);
}
catch (FormatException)
{
Console.WriteLine($"Unable to parse '{input}'");
}
// Output: Unable to parse ''
try
{
int numVal = Int32.Parse("-105");
Console.WriteLine(numVal);
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
// Output: -105
if (Int32.TryParse("-105", out int j))
{
Console.WriteLine(j);
}
else
{
Console.WriteLine("String could not be parsed.");
}
// Output: -105
try
{
int m = Int32.Parse("abc");
}
catch (FormatException e)
{
Console.WriteLine(e.Message);
}
// Output: Input string was not in a correct format.
const string inputString = "abc";
if (Int32.TryParse(inputString, out int numValue))
{
Console.WriteLine(numValue);
}
else
{
Console.WriteLine($"Int32.TryParse could not parse '{inputString}' to an int.");
}
// Output: Int32.TryParse could not parse 'abc' to an int.
}
}
En el ejemplo siguiente se muestra un enfoque para analizar una cadena que se espera que incluya caracteres numéricos iniciales (incluidos caracteres hexadecimales) y caracteres no numéricos finales. Asigna caracteres válidos desde el principio de una cadena a una nueva cadena antes de llamar al método TryParse. Dado que las cadenas que va a analizar contiene pocos caracteres, el ejemplo llama al método String.Concat para asignar caracteres válidos a una nueva cadena. Para una cadena más larga, se puede usar la clase StringBuilder en su lugar.
using System;
public static class StringConversion
{
public static void Main()
{
var str = " 10FFxxx";
string numericString = string.Empty;
foreach (var c in str)
{
// Check for numeric characters (hex in this case) or leading or trailing spaces.
if ((c >= '0' && c <= '9') || (char.ToUpperInvariant(c) >= 'A' && char.ToUpperInvariant(c) <= 'F') || c == ' ')
{
numericString = string.Concat(numericString, c.ToString());
}
else
{
break;
}
}
if (int.TryParse(numericString, System.Globalization.NumberStyles.HexNumber, null, out int i))
{
Console.WriteLine($"'{str}' --> '{numericString}' --> {i}");
}
// Output: ' 10FFxxx' --> ' 10FF' --> 4351
str = " -10FFXXX";
numericString = "";
foreach (char c in str)
{
// Check for numeric characters (0-9), a negative sign, or leading or trailing spaces.
if ((c >= '0' && c <= '9') || c == ' ' || c == '-')
{
numericString = string.Concat(numericString, c);
}
else
{
break;
}
}
if (int.TryParse(numericString, out int j))
{
Console.WriteLine($"'{str}' --> '{numericString}' --> {j}");
}
// Output: ' -10FFXXX' --> ' -10' --> -10
}
}
Llamada a métodos Convert
En la siguiente tabla se muestran algunos de los métodos de la clase Convert que se pueden usar para convertir una cadena en un número.
Tipo numérico | Método |
---|---|
decimal |
ToDecimal(String) |
float |
ToSingle(String) |
double |
ToDouble(String) |
short |
ToInt16(String) |
int |
ToInt32(String) |
long |
ToInt64(String) |
ushort |
ToUInt16(String) |
uint |
ToUInt32(String) |
ulong |
ToUInt64(String) |
En este ejemplo, se llama al método Convert.ToInt32(String) para convertir una cadena de entrada en un valor int. En el ejemplo se detectan las dos excepciones más comunes producidas por este método: FormatException y OverflowException. Si se puede incrementar el número resultante sin exceder Int32.MaxValue, el ejemplo suma 1 al resultado y muestra la salida.
using System;
public class ConvertStringExample1
{
static void Main(string[] args)
{
int numVal = -1;
bool repeat = true;
while (repeat)
{
Console.Write("Enter a number between −2,147,483,648 and +2,147,483,647 (inclusive): ");
string? input = Console.ReadLine();
// ToInt32 can throw FormatException or OverflowException.
try
{
numVal = Convert.ToInt32(input);
if (numVal < Int32.MaxValue)
{
Console.WriteLine("The new value is {0}", ++numVal);
}
else
{
Console.WriteLine("numVal cannot be incremented beyond its current value");
}
}
catch (FormatException)
{
Console.WriteLine("Input string is not a sequence of digits.");
}
catch (OverflowException)
{
Console.WriteLine("The number cannot fit in an Int32.");
}
Console.Write("Go again? Y/N: ");
string? go = Console.ReadLine();
if (go?.ToUpper() != "Y")
{
repeat = false;
}
}
}
}
// Sample Output:
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 473
// The new value is 474
// Go again? Y/N: y
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 2147483647
// numVal cannot be incremented beyond its current value
// Go again? Y/N: y
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): -1000
// The new value is -999
// Go again? Y/N: n