C# int.TryParse 的实际工作原理
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/15294878/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
How the int.TryParse actually works
提问by speti43
I've looked for int.TryParsemethod implementation, how does it work actually, but I haven't found. I have to know, about a string, whether it's a numeric value, but I don't want to convert it at the this time.
我一直在寻找int.TryParse方法实现，它实际上是如何工作的，但我还没有找到。我必须知道，关于 a string，它是否是一个数值，但我现在不想转换它。
So I need only the boolresult from int.TryParse. So the questions are:
所以我只需要bool从结果int.TryParse。所以问题是：
- Is there any function which can provide only the
boolresult,
- 有没有只能提供
bool结果的函数，
and
和
- I'd like to know, how the
int.TryParseactually works (is there atry ... catchinside or iterates through the characters of inputstring)?
- 我想知道，
int.TryParse实际是如何工作的（是否有try ... catch内部或遍历 input 的字符string）？
采纳答案by Tim Schmelter
If you only need the boolresult, just use the return value and ignore the outparameter.
如果您只需要bool结果，只需使用返回值并忽略out参数。
bool successfullyParsed = int.TryParse(str, out ignoreMe);
if (successfullyParsed){
// ...
}
Edit: Meanwhile you can also have a look at the original source code:
编辑：同时您还可以查看原始源代码：
If i want to know how something is actually implemented, i'm using ILSpyto decompile the .NET-code.
如果我想知道某些东西是如何实际实现的，我正在使用ILSpy反编译 .NET 代码。
This is the result:
这是结果：
// int
/// <summary>Converts the string representation of a number to its 32-bit signed integer equivalent. A return value indicates whether the operation succeeded.</summary>
/// <returns>true if s was converted successfully; otherwise, false.</returns>
/// <param name="s">A string containing a number to convert. </param>
/// <param name="result">When this method returns, contains the 32-bit signed integer value equivalent to the number contained in s, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is null, is not of the correct format, or represents a number less than <see cref="F:System.Int32.MinValue"></see> or greater than <see cref="F:System.Int32.MaxValue"></see>. This parameter is passed uninitialized. </param>
/// <filterpriority>1</filterpriority>
public static bool TryParse(string s, out int result)
{
return Number.TryParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}
// System.Number
internal unsafe static bool TryParseInt32(string s, NumberStyles style, NumberFormatInfo info, out int result)
{
byte* stackBuffer = stackalloc byte[1 * 114 / 1];
Number.NumberBuffer numberBuffer = new Number.NumberBuffer(stackBuffer);
result = 0;
if (!Number.TryStringToNumber(s, style, ref numberBuffer, info, false))
{
return false;
}
if ((style & NumberStyles.AllowHexSpecifier) != NumberStyles.None)
{
if (!Number.HexNumberToInt32(ref numberBuffer, ref result))
{
return false;
}
}
else
{
if (!Number.NumberToInt32(ref numberBuffer, ref result))
{
return false;
}
}
return true;
}
And no, i cannot see any Try-Catchson the road:
不，我Try-Catchs在路上看不到任何东西：
// System.Number
private unsafe static bool TryStringToNumber(string str, NumberStyles options, ref Number.NumberBuffer number, NumberFormatInfo numfmt, bool parseDecimal)
{
if (str == null)
{
return false;
}
fixed (char* ptr = str)
{
char* ptr2 = ptr;
if (!Number.ParseNumber(ref ptr2, options, ref number, numfmt, parseDecimal) || ((ptr2 - ptr / 2) / 2 < str.Length && !Number.TrailingZeros(str, (ptr2 - ptr / 2) / 2)))
{
return false;
}
}
return true;
}
// System.Number
private unsafe static bool ParseNumber(ref char* str, NumberStyles options, ref Number.NumberBuffer number, NumberFormatInfo numfmt, bool parseDecimal)
{
number.scale = 0;
number.sign = false;
string text = null;
string text2 = null;
string str2 = null;
string str3 = null;
bool flag = false;
string str4;
string str5;
if ((options & NumberStyles.AllowCurrencySymbol) != NumberStyles.None)
{
text = numfmt.CurrencySymbol;
if (numfmt.ansiCurrencySymbol != null)
{
text2 = numfmt.ansiCurrencySymbol;
}
str2 = numfmt.NumberDecimalSeparator;
str3 = numfmt.NumberGroupSeparator;
str4 = numfmt.CurrencyDecimalSeparator;
str5 = numfmt.CurrencyGroupSeparator;
flag = true;
}
else
{
str4 = numfmt.NumberDecimalSeparator;
str5 = numfmt.NumberGroupSeparator;
}
int num = 0;
char* ptr = str;
char c = *ptr;
while (true)
{
if (!Number.IsWhite(c) || (options & NumberStyles.AllowLeadingWhite) == NumberStyles.None || ((num & 1) != 0 && ((num & 1) == 0 || ((num & 32) == 0 && numfmt.numberNegativePattern != 2))))
{
bool flag2;
char* ptr2;
if ((flag2 = ((options & NumberStyles.AllowLeadingSign) != NumberStyles.None && (num & 1) == 0)) && (ptr2 = Number.MatchChars(ptr, numfmt.positiveSign)) != null)
{
num |= 1;
ptr = ptr2 - (IntPtr)2 / 2;
}
else
{
if (flag2 && (ptr2 = Number.MatchChars(ptr, numfmt.negativeSign)) != null)
{
num |= 1;
number.sign = true;
ptr = ptr2 - (IntPtr)2 / 2;
}
else
{
if (c == '(' && (options & NumberStyles.AllowParentheses) != NumberStyles.None && (num & 1) == 0)
{
num |= 3;
number.sign = true;
}
else
{
if ((text == null || (ptr2 = Number.MatchChars(ptr, text)) == null) && (text2 == null || (ptr2 = Number.MatchChars(ptr, text2)) == null))
{
break;
}
num |= 32;
text = null;
text2 = null;
ptr = ptr2 - (IntPtr)2 / 2;
}
}
}
}
c = *(ptr += (IntPtr)2 / 2);
}
int num2 = 0;
int num3 = 0;
while (true)
{
if ((c >= '0' && c <= '9') || ((options & NumberStyles.AllowHexSpecifier) != NumberStyles.None && ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))))
{
num |= 4;
if (c != '0' || (num & 8) != 0)
{
if (num2 < 50)
{
number.digits[(IntPtr)(num2++)] = c;
if (c != '0' || parseDecimal)
{
num3 = num2;
}
}
if ((num & 16) == 0)
{
number.scale++;
}
num |= 8;
}
else
{
if ((num & 16) != 0)
{
number.scale--;
}
}
}
else
{
char* ptr2;
if ((options & NumberStyles.AllowDecimalPoint) != NumberStyles.None && (num & 16) == 0 && ((ptr2 = Number.MatchChars(ptr, str4)) != null || (flag && (num & 32) == 0 && (ptr2 = Number.MatchChars(ptr, str2)) != null)))
{
num |= 16;
ptr = ptr2 - (IntPtr)2 / 2;
}
else
{
if ((options & NumberStyles.AllowThousands) == NumberStyles.None || (num & 4) == 0 || (num & 16) != 0 || ((ptr2 = Number.MatchChars(ptr, str5)) == null && (!flag || (num & 32) != 0 || (ptr2 = Number.MatchChars(ptr, str3)) == null)))
{
break;
}
ptr = ptr2 - (IntPtr)2 / 2;
}
}
c = *(ptr += (IntPtr)2 / 2);
}
bool flag3 = false;
number.precision = num3;
number.digits[(IntPtr)num3] = 'int temp;
if (int.TryParse(inputString, out temp))
{
// do stuff
}
';
if ((num & 4) != 0)
{
if ((c == 'E' || c == 'e') && (options & NumberStyles.AllowExponent) != NumberStyles.None)
{
char* ptr3 = ptr;
c = *(ptr += (IntPtr)2 / 2);
char* ptr2;
if ((ptr2 = Number.MatchChars(ptr, numfmt.positiveSign)) != null)
{
c = *(ptr = ptr2);
}
else
{
if ((ptr2 = Number.MatchChars(ptr, numfmt.negativeSign)) != null)
{
c = *(ptr = ptr2);
flag3 = true;
}
}
if (c >= '0' && c <= '9')
{
int num4 = 0;
do
{
num4 = num4 * 10 + (int)(c - '0');
c = *(ptr += (IntPtr)2 / 2);
if (num4 > 1000)
{
num4 = 9999;
while (c >= '0' && c <= '9')
{
c = *(ptr += (IntPtr)2 / 2);
}
}
}
while (c >= '0' && c <= '9');
if (flag3)
{
num4 = -num4;
}
number.scale += num4;
}
else
{
ptr = ptr3;
c = *ptr;
}
}
while (true)
{
if (!Number.IsWhite(c) || (options & NumberStyles.AllowTrailingWhite) == NumberStyles.None)
{
bool flag2;
char* ptr2;
if ((flag2 = ((options & NumberStyles.AllowTrailingSign) != NumberStyles.None && (num & 1) == 0)) && (ptr2 = Number.MatchChars(ptr, numfmt.positiveSign)) != null)
{
num |= 1;
ptr = ptr2 - (IntPtr)2 / 2;
}
else
{
if (flag2 && (ptr2 = Number.MatchChars(ptr, numfmt.negativeSign)) != null)
{
num |= 1;
number.sign = true;
ptr = ptr2 - (IntPtr)2 / 2;
}
else
{
if (c == ')' && (num & 2) != 0)
{
num &= -3;
}
else
{
if ((text == null || (ptr2 = Number.MatchChars(ptr, text)) == null) && (text2 == null || (ptr2 = Number.MatchChars(ptr, text2)) == null))
{
break;
}
text = null;
text2 = null;
ptr = ptr2 - (IntPtr)2 / 2;
}
}
}
}
c = *(ptr += (IntPtr)2 / 2);
}
if ((num & 2) == 0)
{
if ((num & 8) == 0)
{
if (!parseDecimal)
{
number.scale = 0;
}
if ((num & 16) == 0)
{
number.sign = false;
}
}
str = ptr;
return true;
}
}
str = ptr;
return false;
}
回答by anaximander
Just because int.TryParsegives you the value doesn't mean you need to keep it; you can quite happily do this:
仅仅因为int.TryParse给了你价值并不意味着你需要保留它；你可以很高兴地这样做：
private static Regex regexInt = new Regex("^\d+$");
static bool CheckReg(string value)
{
return regexInt.IsMatch(value);
}
You can ignore tempentirely if you don't need it. If you do need it, then hey, it's waiting for you when you want it.
temp如果你不需要它，你可以完全忽略它。如果您确实需要它，那么嘿，它会在您需要的时候等着您。
As for the internals, as far as I remember it attempts to read the raw bytes of the string as an int and tests whether the result is valid, or something; it's not as simple as iterating through looking for non-numeric characters.
至于内部结构，据我所知，它尝试将字符串的原始字节读取为 int 并测试结果是否有效或其他内容；它不像通过查找非数字字符进行迭代那么简单。
回答by paparazzo
Regex is compiled so for speed create it once and reuse it.
The new takes longer than the IsMatch.
This only checks for all digits.
It does not check for range.
If you need to test range then TryParse is the way to go.
正则表达式被编译以便速度创建它一次并重用它。
新的需要比 IsMatch 更长的时间。
这仅检查所有数字。
它不检查范围。
如果您需要测试范围，那么 TryParse 是您的最佳选择。
class Program
{
static void Main()
{
string str = "7788";
int num1;
bool n = int.TryParse(str, out num1);
Console.WriteLine(num1);
Console.ReadLine();
}
}
回答by Syed
Check this simple program to understand int.TryParse
检查这个简单的程序以了解 int.TryParse
int nNumber = int.TryParse("InputString", out nNumber) ? nNumber : 1;
Output is : 7788
输出为：7788
回答by Zolfaghari
TryParse is the best way for parse or validate in single line:
TryParse 是单行解析或验证的最佳方式：
if (int.TryParse(inputString, out _))
{
//do stuff
}
Short description:
简短的介绍：
- nNumber will initialize with zero,
- int.TryParse() try parse "InputString" and validate it, if succeed set into nNumber.
- short if ?: checking int.TryParse() result, that return nNumber or 1 as default value.
- nNumber 将初始化为零，
- int.TryParse() 尝试解析“InputString”并验证它，如果成功设置为 nNumber。
- short if ?: 检查 int.TryParse() 结果，返回 nNumber 或 1 作为默认值。
回答by RFE Petr
We can now in C# 7.0 and above write this:
我们现在可以在 C# 7.0 及更高版本中这样写：
##代码##