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

Question

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

Answer 1

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

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

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

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

Answer 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's) комментарии.

Answer 3

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

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

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

Answer 4

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

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

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

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

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

• Integer в RANGE> возвращает целочисленное значение, 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);
        }
    }

Answer 5

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

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

Answer 6

TryParse быстрее ...

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

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

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

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

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

Answer 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 

Answer 8

Convert.ToInt32

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

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

Object, Boolean, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, одинарный, двойной, десятичный, строка, дата

и у него также есть ряд других методов; один из них связан с числовой базой, а два метода включают 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 )

Answer 9

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

Answer 10

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

ВЫ ПРЕДУПРЕЖДЕНЫ!

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

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