int.Parse（）和Convert.ToInt32之间的主要区别是什么

492
  • int.Parse()和之间的主要区别是Convert.ToInt32()什么？
  • 哪一个是首选
c# 
— jbcedge
source

Answers:

448

  • 如果您有一个字符串，并且希望它始终是整数（例如，如果某些Web服务将字符串格式的整数交给您），则可以使用Int32.Parse()。

  • 如果您要收集用户的输入，通常会使用Int32.TryParse()，因为它可以让您对用户输入无效输入时的情况进行更细粒度的控制。

  • Convert.ToInt32()将对象作为其参数。（有关其工作原理，请参见Chris S的答案）

    Convert.ToInt32()ArgumentNullException当其参数为null时，也不会像方法那样抛出Int32.Parse()。这也意味着它Convert.ToInt32()可能比慢一点Int32.Parse()，尽管实际上，除非您在循环中进行大量迭代，否则您永远不会注意到它。

— 戴夫·马克尔
source
54
正如其他人指出的那样，当s为null时，Convert.ToInt32（s）不会引发异常，但是Parse（）会引发异常。“慢一点”完全没有意义，因为您永远也无法衡量差异。
— 罗伯特·保尔森
4
谢谢，罗伯特！我正在编辑我的答案以获得更多完整性。但是就性能而言，我敢打赌，如果您在嵌套循环中调用它，则速度的差异将是可检测的...
— Dave Markle
5
实际上，由于该ToInt32方法对于类型的负载有重载，因此，在System.String识别类型时不会浪费时间。实际的代码什么也不做，只为空值和int.Parse(value, CultureInfo.CurrentCulture)其他所有内容返回0 。
— Andreas Eriksson
6
@StealthRabbi：在文档的“返回值”部分中：“一个32位有符号整数，它等于value中的数字，如果value为null，则为0（零）。”
— 戴夫·马克尔2013年
3
请删除您对Int32.TryParse()in 的提及，Convert.ToInt32()因为它不正确。如果字符串格式错误，则Convert会引发异常。
— Dehalion 2014年
190

看看反射器：

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

正如第一个（戴夫M的）评论所说。

— 克里斯·S
source
19
感谢您删除先前回答中的所有猜想。
— bopapa_1979 2012年
1
不应该是“ return default（int）;” ？
— SkorunkaFrantišek2012年
2
总之，Convert.ToInt32返回0如果null要防止int.Parse从提高的ArgumentNullException。
— 安德烈Leria
4
@SkorunkaFrantišek-该表达式default(int)在编译时求值，因为它是一个固有值-表达式的结果为0，所以编译器会插入一个文字0。IL拆卸工具无所不能，因此只向您显示文字零。
— antiduh 2014年
4
@SkorunkaFrantišek这完全不是重点。用户正在复制反映的代码。进行更改将是对编译内容的不正确表示。如果用户具有原始来源，而原始来源具有default（int），则这将是用户发布的内容。
— rshadman
78

这样没有区别。内部
Convert.ToInt32()通话int.Parse()

当参数为时，除了一件事Convert.ToInt32()返回0null

否则两者的工作方式相同

— Shahkalpesh
source
5
更准确地说，是内部Convert.ToInt32(string)通话int.Parse。Convert.ToInt32(object)然而，通话((IConvertible) value).ToInt32，在string通话中Convert.ToInt32(string)……有点令人费解……
— Timwi
3
是的，Convert.ToInt32（char）实际上将返回（int）值，它将“ 1”变成49。通常不是预期的功能。
— Dale K
32

int.Parse（字符串s）

  • RANGE中的整数>返回整数值
  • 空值> ArguementNullException
  • 格式不正确> FormatException
  • 值不在RANGE> OverflowException中

Convert.ToInt32（字符串s）

  • RANGE中的整数>返回整数值
  • 空值>返回“ 0”
  • 格式不正确> FormatException
  • 值不在RANGE> OverflowException中

bool isParsed = int.TryParse（string s，out res）

  • 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);
        }
    }
— NITHIN RAJ T
source
— 丹尼尔乙
22

区别是：

Int32.Parse()并且Int32.TryParse()只能转换字符串。Convert.ToInt32()可以接受任何实现的类IConvertible。如果将字符串传递给它，则它们是等效的，除了会为类型比较等带来额外的开销。如果要转换字符串，则TryParse()可能是更好的选择。

— 马修·沙利（Matthew Scharley）
source
8

TryParse更快...

这些功能中的第一个功能Parse是任何.Net开发人员都应该熟悉的功能。此函数将获取一个字符串，并尝试从中提取一个整数，然后返回该整数。如果遇到无法解析的内容，则抛出FormatException，或者如果数字太大，则抛出OverflowException。另外，如果您将其传递为null值，则它可能引发ArgumentException。

TryParse是新的.Net 2.0框架的新增功能，它解决了原始Parse函数的某些问题。主要区别在于异常处理非常慢，因此，如果TryParse无法解析字符串，则它不会像Parse一样引发异常。而是返回一个布尔值，指示它是否能够成功解析数字。因此，您必须将要解析的字符串和要填充的Int32 out参数都传递到TryParse中。在可以正确解析字符串的两种情况下，以及在其中该字符串无法正确解析。

Convert类包含一系列将一个基类转换为另一个基类的函数。我相信Convert.ToInt32（string）只是检查一个空字符串（如果该字符串为null，则与Parse不同，它返回零），然后仅调用Int32.Parse（string）。我将使用探查器来确认这一点，并查看使用转换（而不是解析）对性能是否有任何实际影响。

实例来源

希望这可以帮助。

— 螺栓诱饵
source
3
当您查看TryParse的源代码时，它实际上根本没有任何异常处理-只是字符操作和位移，感谢链接
— Chris
2
根据这些基准，除非您要转换超过200万个对象，否则Parse，TryParse和Convert的速度几乎相同。
— Free Coder 2015年
8

Int32.parse（字符串）--->

Int32.Parse（字符串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（string）-> 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
— 索努·拉杰波特（Sonu Rajpoot）
source
1
— T.Todua
4 
Convert.ToInt32

有19个重载或您可以调用它的19种不同方式。在2010版本中可能更多。

它将尝试从以下类型转换：

对象，布尔值，字符，SByte，字节，Int16，UInt16，Int32，UInt32，Int64，UInt64，单，双精度，十进制，字符串，日期

它还有许多其他方法；一个与数字基有关，而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 )
— 沙什·谢克尔
source
2

这取决于参数类型。例如，我今天才发现，它将使用其ASCII值将char直接转换为int。不完全是我想要的功能...

你被警告了！

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

Convert.ToInt32('1'); // Returns 49
int.Parse('1'); // Returns 1
— 戴尔·K
source
可以在C＃中char隐式转换为string吗？在VB.NET中肯定可以，因此使用该语言的程序员可能会期望Convert.ToInt32("1"c)并Convert.ToInt32("1")等效，但是我不认为C＃具有这种隐式转换。
— 2013年
您不能将char隐式或显式转换为字符串。您需要调用“ 1” .ToString（）或新字符串（“ 1”，1）；
— Dale K
3
我不会认为“警告”对于C＃来说意义重大，因为该语言将char值视为比vb.net稍微有点数字。在vb.net中，危险会更大，在那儿由于隐式强制转换，Char和之间的感知差异较小String。
— 2013年
2

这是int.Parseand 的详细信息Convert.ToInt32：假设您有一个char数组，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输出将没有差异。两者都返回正确的整数。

— 考拉程序员
source
1

Convert.ToInt32允许空值，它不会引发任何错误Int.parse不允许空值，它引发ArgumentNullException错误。

— 什拉达茹里
source
1

为了澄清打开控制台应用程序，只需复制以下代码并将其粘贴到 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();
        }
    }
— 普拉迪普·库玛（Pradeep Kumar）
source
1

Parse（）方法提供了不能用于​​Convert（）的数字样式。例如：

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

会使用尾号来解析数字，因此i == -123
尾号在ERP系统中很流行。

— 西尔维斯特·桑托罗夫斯基（Sylwester Santorowski）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.