Какое основное отличие между int.Parse() и Convert.ToInt32

  • В чем основное отличие между int.Parse() и Convert.ToInt32()?
  • Какой из них предпочтительнее

ОТВЕТЫ

Ответ 1

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

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

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

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

Ответ 2

Посмотрите в рефлекторе:

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

Как говорится в первом комментарии (Dave M).

Ответ 3

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

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

В противном случае обе работают одинаково

Ответ 4

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

  • Целое число в RANGE > возвращает целочисленное значение
  • Значение Null > АргументNullException
  • Не в формате > FormatException
  • Значение не в RANGE > OverflowException

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

  • Целое число в RANGE > возвращает целочисленное значение
  • Значение Null > возвращает "0"
  • Не в формате > FormatException
  • Значение не в RANGE > OverflowException

bool isParsed = int.TryParse(строка s, out res)

  • Целое число в RANGE > возвращает целочисленное значение, isParsed = true
  • Значение Null > возвращает "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);
        }
    }

Ответ 5

Разница заключается в следующем:

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

Ответ 6

TryParse быстрее...

Первая из этих функций, Parse, является той, которая должна быть знакома любой разработчик .Net. Эта функция примет строку и попытается извлечь из него целое число и затем вернуть целое число. Если он работает во что-то, что он не может проанализировать, тогда он выдает исключение FormatException или если число слишком велико, OverflowException. Кроме того, он может ArgumentException, если вы передадите ему нулевое значение.

TryParse - новое дополнение к новой инфраструктуре .Net 2.0, которая устраняет некоторые проблемы с оригинальной функцией Parse. Главный разница в том, что обработка исключений очень медленная, поэтому, если TryParse не удается разобрать строку, она не генерирует исключение, такое как Parse делает. Вместо этого он возвращает логическое значение, указывающее, удалось ли успешно проанализировать число. Итак, вы должны перейти в TryParse как строка, подлежащая анализу, и параметр Int32 out для заполнения. Мы будем используйте профилировщик для проверки разницы в скорости между TryParse и Разбор в обоих случаях, когда строка может быть правильно разобрана и в случаи, когда строка не может быть правильно разобрана.

Класс Convert содержит ряд функций для преобразования одного базового класса в другой. я полагаю, что Convert.ToInt32 (строка) просто проверяет пустую строку (если строка null возвращает нуль в отличие от Parse), а затем просто вызывает Int32.Parse(строка). Я использую профилировщик, чтобы подтвердить это и увидеть если использование Convert в отличие от Parse имеет какое-либо реальное влияние на производительность.

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

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

Ответ 7

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

Ответ 8

Convert.ToInt32

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

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

Объект, Boolean, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, String, Date

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

С другой стороны, у парсера есть только 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 )

Ответ 9

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

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

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

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

Ответ 10

Вот подробности для 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 будут иметь разницы в выводе. Оба возвращают правильное целое число.

Ответ 11

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

Ответ 12

для пояснения открытое консольное приложение, просто скопируйте ниже код и вставьте его в метод 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();
        }
    }

Ответ 13

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

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

будет анализировать числа с последним знаком, так что я == -123
Трейлинг-знак популярен в системах ERP.