В чем основное различие между int.Разбор () и преобразование.ToInt32


  • в чем основная разница между int.Parse() и Convert.ToInt32()?

  • какой из них следует предпочесть

331   12  
c#

12 ответов:

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

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

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

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

391  
2017-10-23 17:22:22

взгляните в отражатель:

int.Разбор("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;
}

преобразовать.ToInt32("32"):

public static int ToInt32(string value)
{
    if (value == null)
    {
        return 0;
    }
    return int.Parse(value, CultureInfo.CurrentCulture);
}

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

160  
2008-10-14 17:32:23

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

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

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

64  
2015-08-18 07:00:16

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

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

20  
2010-03-20 01:22:05

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

  • Integer in RANGE > возвращает целочисленное значение
  • нулевое значение > ArguementNullException
  • не в формате > FormatException
  • значение не в диапазоне > OverflowException

преобразовать.ToInt32(строка s)

  • Integer in RANGE > возвращает целочисленное значение
  • значение null > возвращает "0"
  • не в формате > FormatException
  • значение не в диапазоне > OverflowException

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

  • Integer in RANGE > возвращает целочисленное значение, isParsed = true
  • Null value > возвращает "0", isParsed = false
  • не в формате > возвращает "0", isParsed = ложь
  • значение не в диапазоне > возвращает "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);
        }
    }
20  
2016-08-10 10:12:29

TryParse быстрее...

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

TryParse это новое дополнение к новой платформе .Net 2.0, которое устраняет некоторые проблемы с исходной функцией синтаксического анализа. Основное разница в том, что обработка исключений очень медленная, поэтому если TryParse не удается разобрать строку он не вызывает исключение, как разбор делает. Вместо этого он возвращает логическое значение, указывающее, смог ли он успешно разобрать число. Так что вы должны пройти в TryParse оба строка, которая будет проанализирована и int32 параметры для заполнения. Мы будем используйте профилировщик для изучите разницу в скорости между TryParse и Синтаксический анализ в обоих случаях, когда строка может быть правильно проанализирована и в случаи, когда строка не может быть правильно проанализирована.

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

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

надеюсь, что это помогает.

8  
2012-08-08 22:59:57

типа int32.разбор (строка) - - ->

типа 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

преобразовать.ToInt32(строка) --> Конвертировать.Метод 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
6  
2017-10-26 11:16:01 
Convert.ToInt32

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

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

"Объект", Логическое Значение, Знак, Типа Sbyte, Байт, Типа INT16, Типа Uint16, Int32 И Тип Uint32, Типа Int64, Uint64 В, Один, Двойной, Десятичное Число, Строка, Дата

и он также имеет ряд других методов; один из них связан с базой чисел, а 2 метода включают 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 )
3  
2012-08-07 17:42:48

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

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

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

Convert.ToInt32('1'); // Returns 49
int.Parse('1'); // Returns 1
2  
2013-10-22 00:03:54

преобразовать.ToInt32 допускает нулевое значение, он не выдает никаких ошибок Int.синтаксический анализ не позволяет значение null, он выдает ошибку ArgumentNullException.

1  
2011-11-14 12:23:24

для уточнения откройте консольное приложение, Просто скопируйте ниже код и вставьте его в 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();
        }
    }
1  
2012-08-03 10:26:27

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

1  
2018-02-15 10:18:23

Comments

    Ничего не найдено.
Click here to cancel reply.