• ¿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 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á.

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).

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

int.Parse (cadena s)

• Entero en RANGO> devuelve el valor entero
• Valor nulo> ArguementNullException
• No en formato> Excepción de formato
• Valor no en RANGE> OverflowException

Convert.ToInt32 (cadena s)

• Entero en RANGO> devuelve el valor entero
• Valor nulo> devuelve "0"
• No en formato> Excepción de formato
• Valor no en RANGE> OverflowException

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

• Entero en RANGO> devuelve el valor entero, isParsed = true
• Valor nulo> devuelve "0", isParsed = false
• No en formato> devuelve "0", isParsed = false
• El valor no está en RANGO> devuelve "0", isParsed = false

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.

Fuente con ejemplos

Espero que esto ayude.

Convert.ToInt32

tiene 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 1

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.