Respuestas:
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), lo usaría Int32.Parse().
Si está recopilando información de un usuario, generalmente la usaría Int32.TryParse(), ya que le permite un control más detallado sobre la situación cuando el usuario ingresa información no válida.
Convert.ToInt32()toma un objeto como argumento. (Vea la respuesta de Chris S para ver cómo funciona)
Convert.ToInt32()tampoco arroja ArgumentNullExceptioncuando su argumento es nulo como lo Int32.Parse()hace. Eso también significa que Convert.ToInt32()probablemente sea un poco 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á.
ToInt32método tiene una sobrecarga para muchos tipos, entre ellos System.String, no se perderá tiempo en discernir el tipo. El código real no hace nada más que devolver 0 para valores nulos y int.Parse(value, CultureInfo.CurrentCulture)para todo lo demás.
Int32.TryParse()in Convert.ToInt32()porque es incorrecta. Convertir arroja una excepción si la cadena tiene un formato incorrecto.
Echa un vistazo en 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).
Convert.ToInt32devuelve 0si nullpara evitar int.Parsesubir un ArgumentNullException.
default(int)se evalúa en tiempo de compilación, ya que es un valor intrínseco; el resultado de la expresión es 0, por lo que el compilador inserta un literal 0. Las herramientas de desmontaje de IL no pueden conocerlo mejor, por lo que solo le muestran un cero literal.
No hay diferencia como tal.
Convert.ToInt32()llamadas int.Parse()internas
Excepto por una cosa que Convert.ToInt32()regresa 0cuando el argumento esnull
De lo contrario, ambos funcionan de la misma manera
Convert.ToInt32(string)llama int.Parseinternamente. Convert.ToInt32(object), sin embargo, llamadas ((IConvertible) value).ToInt32, que en el caso de las stringllamadas Convert.ToInt32(string)... un poco enrevesadas ...
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);
}
}
La diferencia es esta:
Int32.Parse()y Int32.TryParse()solo puede convertir cadenas. Convert.ToInt32()puede tomar cualquier clase que implemente IConvertible. Si le pasa una cadena, entonces son equivalentes, excepto que obtiene una sobrecarga adicional para las comparaciones de tipos, etc. Si está convirtiendo cadenas, entonces TryParse()probablemente sea la mejor opción.
Int32.parse (string) --->
El método Int32.Parse (string s) convierte la representación de cadena de un número a su equivalente entero de 32 bits con signo. Cuando s es una referencia nula, arrojará ArgumentNullException. Si s no es un valor entero, arrojará FormatException. Cuando s representa un número menor que MinValue o mayor que MaxValue, arrojará 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
Convert.ToInt32 (string) -> El método Convert.ToInt32 (string s) convierte la representación de cadena especificada del equivalente entero de 32 bits con signo. 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, arrojará FormatException. Cuando s representa un número menor que MinValue o mayor que MaxValue, arrojará OverflowException.
Por ejemplo:
result = Convert.ToInt32(s1); // 1234
result = Convert.ToInt32(s2); // FormatException
result = Convert.ToInt32(s3); // 0
result = Convert.ToInt32(s4); // OverflowException
TryParse es más rápido ...
La primera de estas funciones, Parse, debe ser familiar para cualquier desarrollador de .Net. Esta función tomará una cadena e intentará extraer un número entero y luego devolver el número entero. Si se encuentra con algo que no puede analizar, arroja una Excepción de formato o si el número es demasiado grande, una Excepción de desbordamiento. Además, puede lanzar una excepción ArgumentException si le pasa un valor nulo.
TryParse es una nueva adición al nuevo marco .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 arroja una excepción como lo hace Parse. En cambio, devuelve un booleano que indica si pudo analizar con éxito un número. Por lo tanto, debe pasar a TryParse tanto la cadena que se analizará como un parámetro de salida Int32 para completar. Usaremos el perfilador para examinar la diferencia de velocidad entre TryParse y Parse en ambos casos donde la cadena se puede analizar correctamente y en los casos en que la cadena no se puede analizar 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). Usaré el generador de perfiles para confirmar esto y ver si usar Convertir en lugar de Parse tiene algún efecto real en el rendimiento.
Espero que esto ayude.
Convert.ToInt32tiene 19 sobrecargas o 19 formas diferentes de llamarlo. Quizás más en las versiones de 2010.
Intentará convertir de los siguientes TIPOS;
Objeto, booleano, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, String, Date
y también tiene varios otros métodos; uno que tiene que ver con una base numérica y 2 métodos implican unaSystem.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 1charconvertir implícitamente stringen C #? Ciertamente puede en VB.NET, por lo que los programadores en ese lenguaje probablemente esperarían Convert.ToInt32("1"c)y Convert.ToInt32("1")serían equivalentes, pero no creo que C # tenga esa conversión implícita.
charvalores son un poco más numéricos que vb.net. El peligro sería mayor en vb.net, donde debido a un reparto implícito hay menos diferencia percibida entre Chary String.
Aquí hay un detalle para int.Parsey Convert.ToInt32: Digamos que tiene una matriz de caracteres char[] a=['1','2','3','4']y desea convertir cada elemento en un entero. El Convert.ToInt32(a[0])le dará un número de 49. Lo trata como un código ASCII El int.Parse(a[0])le dará la salida correcta que es 1
Si usted tiene una matriz de cadenas string[] b=['1','2','3','4'], a continuación, Convert.ToInt32y int.Parseno tendrá ninguna diferencia en la salida. Ambos devuelven el entero correcto.
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 consola abierta, solo copie el código a continuación y péguelo en el static void Main(string[] args)método, 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();
}
}Los métodos Parse () proporcionan los estilos numéricos que no se pueden usar para Convert (). Por ejemplo:
int i;
bool b = int.TryParse( "123-",
System.Globalization.NumberStyles.AllowTrailingSign,
System.Globalization.CultureInfo.InvariantCulture,
out i);analizaría los números con el signo final de modo que i == -123
El signo final es popular en los sistemas ERP.