¿Cuál es la principal diferencia entre int.Parse () y Convert.ToInt32

  • ¿Cuál es la principal diferencia entre int.Parse() y Convert.ToInt32() ?
  • Cuál es el preferido

  • Si tiene una cadena y espera que siempre sea un número entero (por ejemplo, si un servicio web le entrega un entero en formato de cadena), usaría Int32.Parse() .

  • Si está recostackndo información de un usuario, generalmente usaría Int32.TryParse() , ya que le permite un control más detallado sobre la situación cuando el usuario ingresa una entrada no válida.

  • Convert.ToInt32() toma un objeto como argumento. (Vea la respuesta de Chris S sobre cómo funciona)

    Convert.ToInt32() tampoco arroja ArgumentNullException cuando su argumento es nulo como lo hace Int32.Parse() . Eso también significa que Convert.ToInt32() es probablemente un poquito más lento que Int32.Parse() , aunque en la práctica, a menos que esté haciendo una gran cantidad de iteraciones en un ciclo, nunca lo notará.

Eche un vistazo en el reflector:

int.Parse (“32”):

 public static int Parse(string s) { return System.Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo); } 

que es un llamado a:

 internal static unsafe int ParseInt32(string s, NumberStyles style, NumberFormatInfo info) { byte* stackBuffer = stackalloc byte[1 * 0x72]; NumberBuffer number = new NumberBuffer(stackBuffer); int num = 0; StringToNumber(s, style, ref number, info, false); if ((style & NumberStyles.AllowHexSpecifier) != NumberStyles.None) { if (!HexNumberToInt32(ref number, ref num)) { throw new OverflowException(Environment.GetResourceString("Overflow_Int32")); } return num; } if (!NumberToInt32(ref number, ref num)) { throw new OverflowException(Environment.GetResourceString("Overflow_Int32")); } return num; } 

Convert.ToInt32 (“32”):

 public static int ToInt32(string value) { if (value == null) { return 0; } return int.Parse(value, CultureInfo.CurrentCulture); } 

Como dice el primer comentario (de Dave M).

No hay diferencia como tal.
Convert.ToInt32() llama int.Parse() internamente

Excepto por una cosa Convert.ToInt32() devuelve 0 cuando el argumento es null

De lo contrario, ambos funcionan de la misma manera

La diferencia es esta:

Int32.Parse() e Int32.TryParse() solo pueden convertir cadenas. Convert.ToInt32() puede tomar cualquier clase que implemente IConvertible . Si le pasa una cadena, entonces son equivalentes, excepto que obtiene sobrecarga adicional para las comparaciones de tipos, etc. Si está convirtiendo cadenas, entonces TryParse() es probablemente la mejor opción.

int.Parse (cadena s)

  • Entero en RANGE> devuelve valor entero
  • Valor nulo> ArguementNullException
  • No en formato> FormatException
  • Valor no en RANGE> OverflowException

Convert.ToInt32 (cadena s)

  • Entero en RANGE> devuelve valor entero
  • Valor nulo> devuelve “0”
  • No en formato> FormatException
  • Valor no en RANGE> OverflowException

bool isParsed = int.TryParse (cadena s, salida res)

  • Entero en RANGE> devuelve valor entero, isParsed = true
  • Valor nulo> devuelve “0”, isParsed = falso
  • No en formato> devuelve “0”, isParsed = falso
  • Valor no en RANGE> devuelve “0”, isParsed = falso

Pruebe este código a continuación …..

 class Program { static void Main(string[] args) { string strInt = "24532"; string strNull = null; string strWrongFrmt = "5.87"; string strAboveRange = "98765432123456"; int res; try { // int.Parse() - TEST res = int.Parse(strInt); // res = 24532 res = int.Parse(strNull); // System.ArgumentNullException res = int.Parse(strWrongFrmt); // System.FormatException res = int.Parse(strAboveRange); // System.OverflowException // Convert.ToInt32(string s) - TEST res = Convert.ToInt32(strInt); // res = 24532 res = Convert.ToInt32(strNull); // res = 0 res = Convert.ToInt32(strWrongFrmt); // System.FormatException res = Convert.ToInt32(strAboveRange); //System.OverflowException // int.TryParse(string s, out res) - Test bool isParsed; isParsed = int.TryParse(strInt, out res); // isParsed = true, res = 24532 isParsed = int.TryParse(strNull, out res); // isParsed = false, res = 0 isParsed = int.TryParse(strWrongFrmt, out res); // isParsed = false, res = 0 isParsed = int.TryParse(strAboveRange, out res); // isParsed = false, res = 0 } catch(Exception e) { Console.WriteLine("Check this.\n" + e.Message); } } 

TryParse es más rápido …

La primera de estas funciones, Parse, es una que debería ser familiar para cualquier desarrollador de .Net. Esta función tomará una cadena e intentará extraer un entero de ella y luego devolverá el entero. Si se encuentra con algo que no puede analizar, arroja una FormatException o si el número es demasiado grande, una OverflowException. Además, puede lanzar una ArgumentException si le pasa un valor nulo.

TryParse es una nueva adición al nuevo framework .Net 2.0 que aborda algunos problemas con la función Parse original. La principal diferencia es que el manejo de excepciones es muy lento, por lo que si TryParse no puede analizar la cadena, no lanza una excepción como hace Parse. En cambio, devuelve un booleano que indica si fue capaz de analizar correctamente un número. Por lo tanto, debe pasar a TryParse la secuencia a analizar y un parámetro de salida Int32 para completar. Usaremos el generador de perfiles para examinar la diferencia de velocidad entre TryParse y Parse en ambos casos donde la cadena se puede analizar correctamente y en casos donde la cadena no puede ser analizada correctamente.

La clase Convert contiene una serie de funciones para convertir una clase base en otra. Creo que Convert.ToInt32 (cadena) solo busca una cadena nula (si la cadena es nula, devuelve cero a diferencia de Parse) y luego llama a Int32.Parse (cadena). Utilizaré el generador de perfiles para confirmar esto y para ver si el uso de Convert en lugar de Parse tiene un efecto real en el rendimiento.

Fuente con ejemplos

Espero que esto ayude.

Int32.parse (cadena) —>

El método Int32.Parse (cadena s) convierte la representación de cadena de un número en su entero equivalente de 32 bits con signo. Cuando s es una referencia nula, lanzará ArgumentNullException. Si s es distinto del valor entero, lanzará FormatException. Cuando s representa un número menor que MinValue o mayor que MaxValue, lanzará OverflowException. Por ejemplo :

 string s1 = "1234"; string s2 = "1234.65"; string s3 = null; string s4 = "123456789123456789123456789123456789123456789"; result = Int32.Parse(s1); //1234 result = Int32.Parse(s2); //FormatException result = Int32.Parse(s3); //ArgumentNullException result = Int32.Parse(s4); //OverflowException 

El método Convert.ToInt32 (cadena) -> Convert.ToInt32 (cadena s) convierte la representación de cadena especificada del equivalente entero con signo de 32 bits. Esto llama a su vez el método Int32.Parse (). Cuando s es una referencia nula, devolverá 0 en lugar de arrojar ArgumentNullException. Si s es distinto del valor entero, lanzará FormatException. Cuando s representa un número menor que MinValue o mayor que MaxValue, lanzará OverflowException.

Por ejemplo:

  result = Convert.ToInt32(s1); // 1234 result = Convert.ToInt32(s2); // FormatException result = Convert.ToInt32(s3); // 0 result = Convert.ToInt32(s4); // OverflowException 
 Convert.ToInt32 

tiene 19 sobrecargas o 19 formas diferentes de llamarlo. Tal vez más en las versiones de 2010.

Intentará convertir de los siguientes TIPOS;

Objeto, Boolean, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Individual, Doble, Decimal, Cadena, Fecha

y también tiene una cantidad de otros métodos; uno para hacer con un número base y 2 métodos implican un System.IFormatProvider

Parse, por otro lado, solo tiene 4 sobrecargas o 4 formas diferentes de llamar al método.

 Integer.Parse( s As String) Integer.Parse( s As String, style As System.Globalization.NumberStyles ) Integer.Parse( s As String, provider As System.IFormatProvider ) Integer.Parse( s As String, style As System.Globalization.NumberStyles, provider As System.IFormatProvider ) 

Depende del tipo de parámetro. Por ejemplo, hoy descubrí que convertirá un char directamente a int usando su valor ASCII. No es exactamente la funcionalidad que pretendía …

¡USTED HA SIDO ADVERTIDO!

 public static int ToInt32(char value) { return (int)value; } Convert.ToInt32('1'); // Returns 49 int.Parse('1'); // Returns 1 

Convert.ToInt32 permite el valor nulo, no arroja ningún error. Int.parse no permite el valor nulo, arroja un error ArgumentNullException.

para aclarar la aplicación de la consola abierta, simplemente copie el código debajo y péguelo en el método static void Main(string[] args) , espero que pueda entender

 public class Program { static void Main(string[] args) { int result; bool status; string s1 = "12345"; Console.WriteLine("input1:12345"); string s2 = "1234.45"; Console.WriteLine("input2:1234.45"); string s3 = null; Console.WriteLine("input3:null"); string s4 = "1234567899012345677890123456789012345667890"; Console.WriteLine("input4:1234567899012345677890123456789012345667890"); string s5 = string.Empty; Console.WriteLine("input5:String.Empty"); Console.WriteLine(); Console.WriteLine("--------Int.Parse Methods Outputs-------------"); try { result = int.Parse(s1); Console.WriteLine("OutPut1:" + result); } catch (Exception ee) { Console.WriteLine("OutPut1:"+ee.Message); } try { result = int.Parse(s2); Console.WriteLine("OutPut2:" + result); } catch (Exception ee) { Console.WriteLine("OutPut2:" + ee.Message); } try { result = int.Parse(s3); Console.WriteLine("OutPut3:" + result); } catch (Exception ee) { Console.WriteLine("OutPut3:" + ee.Message); } try { result = int.Parse(s4); Console.WriteLine("OutPut4:" + result); } catch (Exception ee) { Console.WriteLine("OutPut4:" + ee.Message); } try { result = int.Parse(s5); Console.WriteLine("OutPut5:" + result); } catch (Exception ee) { Console.WriteLine("OutPut5:" + ee.Message); } Console.WriteLine(); Console.WriteLine("--------Convert.To.Int32 Method Outputs-------------"); try { result= Convert.ToInt32(s1); Console.WriteLine("OutPut1:" + result); } catch (Exception ee) { Console.WriteLine("OutPut1:" + ee.Message); } try { result = Convert.ToInt32(s2); Console.WriteLine("OutPut2:" + result); } catch (Exception ee) { Console.WriteLine("OutPut2:" + ee.Message); } try { result = Convert.ToInt32(s3); Console.WriteLine("OutPut3:" + result); } catch (Exception ee) { Console.WriteLine("OutPut3:" + ee.Message); } try { result = Convert.ToInt32(s4); Console.WriteLine("OutPut4:" + result); } catch (Exception ee) { Console.WriteLine("OutPut4:" + ee.Message); } try { result = Convert.ToInt32(s5); Console.WriteLine("OutPut5:" + result); } catch (Exception ee) { Console.WriteLine("OutPut5:" + ee.Message); } Console.WriteLine(); Console.WriteLine("--------TryParse Methods Outputs-------------"); try { status = int.TryParse(s1, out result); Console.WriteLine("OutPut1:" + result); } catch (Exception ee) { Console.WriteLine("OutPut1:" + ee.Message); } try { status = int.TryParse(s2, out result); Console.WriteLine("OutPut2:" + result); } catch (Exception ee) { Console.WriteLine("OutPut2:" + ee.Message); } try { status = int.TryParse(s3, out result); Console.WriteLine("OutPut3:" + result); } catch (Exception ee) { Console.WriteLine("OutPut3:" + ee.Message); } try { status = int.TryParse(s4, out result); Console.WriteLine("OutPut4:" + result); } catch (Exception ee) { Console.WriteLine("OutPut4:" + ee.Message); } try { status = int.TryParse(s5, out result); Console.WriteLine("OutPut5:" + result); } catch (Exception ee) { Console.WriteLine("OutPut5:" + ee.Message); } Console.Read(); } } 

Aquí hay un detalle para int.Parse y Convert.ToInt32 : Digamos, tienes una matriz de caracteres, char[] a=['1','2','3','4'] y quieres convertir cada elemento en un entero. El Convert.ToInt32(a[0]) le dará un número de 49. Lo trata como código ASCII. El int.Parse(a[0]) le dará el resultado correcto que es 1

Si tiene una cadena de matriz de string[] b=['1','2','3','4'] , entonces Convert.ToInt32 e int.Parse no tendrán ninguna diferencia en la salida. Ambos devuelven el entero correcto.