c#

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



(12)

int.Parse (cadena s)

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

Convert.ToInt32 (cadena s)

  • Entero en RANGO> devuelve un valor entero
  • Valor nulo> devuelve "0"
  • No en formato> FormatException
  • Valor no en RANGO> OverflowException

bool isParsed = int.TryParse (string s, out res)

  • Integer in RANGE> devuelve un valor entero, isParsed = true
  • Valor nulo> devuelve "0", isParsed = false
  • No en formato> devuelve "0", isParsed = false
  • El valor no en RANGO> devuelve "0", isParsed = false

Intente 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); } }

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

Aquí hay un detalle para int.Parse y Convert.ToInt32 : Digamos que tienes una matriz char, 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á la salida correcta que es 1

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

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

Depende del tipo de parámetro. Por ejemplo, acabo de descubrir hoy 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

Echa 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 una llamada 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).

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 tiene una sobrecarga adicional para las comparaciones de tipos, etc. Si está convirtiendo cadenas, entonces TryParse() es probablemente la mejor opción.

No hay diferencia como tal.
Convert.ToInt32() llama a 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.

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 y luego devolverá el entero. Si se encuentra con algo que no puede analizar, lanza una excepción FormatException o si el número es una excepción OverflowException demasiado grande. Además, puede lanzar una ArgumentException si le pasas un valor nulo.

TryParse es una nueva adición al nuevo marco .Net 2.0 que resuelve 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 lo hace Parse. En su lugar, devuelve un valor booleano que indica si fue capaz de analizar correctamente un número. Por lo tanto, debe pasar a TryParse tanto la cadena a analizar como un parámetro Int32 out 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 del Parse) y luego llama a Int32.Parse (cadena). Usaré el generador de perfiles para confirmar esto y para ver si usar Convert en lugar de Parse tiene algún efecto real en el rendimiento.

Fuente con ejemplos

Espero que esto ayude.

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

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(); } }

Int32.parse (string) --->

El método Int32.Parse (cadena s) convierte la representación de cadena de un número a su equivalente entero con signo de 32 bits. Cuando s es una referencia nula, lanzará ArgumentNullException. Si s no es un 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 al método Int32.Parse (). Cuando s es una referencia nula, devolverá 0 en lugar de lanzar ArgumentNullException. Si s no es un 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 2010.

Intentará convertir de los siguientes TIPOS;

Objeto, Booleano, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Simple, Doble, Decimal, Cadena, Fecha

y también tiene una serie de otros métodos; una para hacer con una base numérica 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 )

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

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

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

    Convert.ToInt32() tampoco lanza la Int32.Parse() 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 bucle, nunca lo notará.