Никакой разницы как таковой. Convert.ToInt32() вызывает внутренний вызов int.Parse()

За исключением одного, Convert.ToInt32() возвращает 0, когда аргумент - null.

В остальном оба работают одинаково

• Если у вас есть строка и вы ожидаете, что она всегда будет целым числом (скажем, если какая-то веб-служба передает вам целое число в строковом формате), вы должны использовать Int32.Parse().

• Если вы собираете ввод от пользователя, вы обычно используете Int32.TryParse(), поскольку он позволяет более детально контролировать ситуацию, когда пользователь вводит недопустимые данные.

• Convert.ToInt32() принимает объект в качестве аргумента. (См. Ответ Криса С., чтобы узнать, как это работает)

  Convert.ToInt32() также не генерирует ArgumentNullException, когда его аргумент равен нулю, как это делает Int32.Parse(). Это также означает, что Convert.ToInt32(), вероятно, немного медленнее, чем Int32.Parse(), хотя на практике, если вы не выполняете очень большое количество итераций в цикле, вы никогда этого не заметите.

TryParse быстрее ...

The first of these functions, Parse, is one that should be familiar to any .Net developer. This function will take a string and attempt to extract an integer out of it and then return the integer. If it runs into something that it can’t parse then it throws a FormatException or if the number is too large an OverflowException. Also, it can throw an ArgumentException if you pass it a null value.

TryParse is a new addition to the new .Net 2.0 framework that addresses some issues with the original Parse function. The main difference is that exception handling is very slow, so if TryParse is unable to parse the string it does not throw an exception like Parse does. Instead, it returns a Boolean indicating if it was able to successfully parse a number. So you have to pass into TryParse both the string to be parsed and an Int32 out parameter to fill in. We will use the profiler to examine the speed difference between TryParse and Parse in both cases where the string can be correctly parsed and in cases where the string cannot be correctly parsed.

The Convert class contains a series of functions to convert one base class into another. I believe that Convert.ToInt32(string) just checks for a null string (if the string is null it returns zero unlike the Parse) then just calls Int32.Parse(string). I’ll use the profiler to confirm this and to see if using Convert as opposed to Parse has any real effect on performance.

Источник с примерами

Надеюсь это поможет.

Разница вот в чем:

Int32.Parse() и Int32.TryParse() могут преобразовывать только строки. Convert.ToInt32() может принимать любой класс, реализующий IConvertible. Если вы передаете ему строку, они эквивалентны, за исключением того, что вы получаете дополнительные накладные расходы на сравнение типов и т. д. Если вы конвертируете строки, то TryParse(), вероятно, будет лучшим вариантом.

Посмотрите в отражатель:

int.Parse ("32"):

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

что является призывом к:

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

Как говорится в первом комментарии (Дэйва М.).

Convert.ToInt32 допускает нулевое значение, он не вызывает никаких ошибок Int.parse не допускает нулевого значения, он выдает ошибку ArgumentNullException.

Convert.ToInt32

имеет 19 перегрузок или 19 различных способов, которые вы можете назвать. Может быть, больше в версиях 2010 года.

Он попытается преобразовать из следующих ТИПОВ;

Object, Boolean, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, String, Date

и у него также есть ряд других методов; один связан с числовой базой, а два метода связаны с System.IFormatProvider

Parse, с другой стороны, имеет только 4 перегрузки или 4 различных способа вызова метода.

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 )

для пояснения откройте консольное приложение, просто скопируйте приведенный ниже код и вставьте его в метод static void Main(string[] args), я надеюсь, вы понимаете

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

Это зависит от типа параметра. Например, я только что обнаружил сегодня, что он преобразует char напрямую в int, используя его значение ASCII. Не совсем та функциональность, которую я планировал ...

ВЫ БЫЛИ ПРЕДУПРЕЖДЕНЫ!

public static int ToInt32(char value)
{
    return (int)value;
} 

Convert.ToInt32('1'); // Returns 49
int.Parse('1'); // Returns 1

Int32.parse (строка) --->

Int32.Parse (string s) преобразует строковое представление числа в его эквивалентное 32-разрядное целое число со знаком. Если s является нулевой ссылкой, она вызовет исключение ArgumentNullException. Если s отличается от целочисленного значения, будет выброшено исключение FormatException. Когда s представляет собой число меньше MinValue или больше MaxValue, это вызовет исключение OverflowException. Например:

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 (строка) -> Convert.ToInt32 (string s) преобразует указанное строковое представление в эквивалент 32-битного целого числа со знаком. Это, в свою очередь, вызывает метод Int32.Parse (). Когда s является пустой ссылкой, она вернет 0, а не выбросит исключение ArgumentNullException. Если s отличается от целочисленного значения, будет выброшено исключение FormatException. Когда s представляет собой число меньше MinValue или больше MaxValue, это вызовет исключение OverflowException.

Например:

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

int.Parse (строка s)

• Целое число в ДИАПАЗОНЕ> возвращает целочисленное значение
• Нулевое значение> ArguementNullException
• Не в формате> FormatException
• Значение не входит в RANGE> OverflowException

Convert.ToInt32 (строка s)

• Целое число в ДИАПАЗОНЕ> возвращает целочисленное значение
• Нулевое значение> возвращает "0"
• Не в формате> FormatException
• Значение не входит в RANGE> OverflowException

bool isParsed = int.TryParse (строка s, исходящее разрешение)

• Целое число в ДИАПАЗОНЕ> возвращает целочисленное значение, isParsed = true
• Нулевое значение> возвращает "0", isParsed = false.
• Не в формате> возвращает «0», isParsed = false
• Значение не в RANGE> возвращает "0", isParsed = false

Попробуйте этот код ниже .....

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

Вот детали для int.Parse и Convert.ToInt32: Скажем, у вас есть массив символов char[] a=['1','2','3','4'], и вы хотите преобразовать каждый элемент в целое число. Convert.ToInt32(a[0]) выдаст вам число 49. Он рассматривает его как код ASCII. int.Parse(a[0]) даст вам правильный выход, который составляет 1

Если у вас есть строковый массив string[] b=['1','2','3','4'], то Convert.ToInt32 и int.Parse не будут иметь разницы в выводе. Оба возвращают правильное целое число.

Методы Parse () предоставляют числовые стили, которые нельзя использовать для Convert (). Например:

int i;
bool b = int.TryParse( "123-",
           System.Globalization.NumberStyles.AllowTrailingSign,
           System.Globalization.CultureInfo.InvariantCulture,
           out i);

будет анализировать числа с конечным знаком так, чтобы i == -123
Завершающий знак популярен в ERP-системах.