blocks|key|2937339|text|这应该是可行的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937340|Regex.IsMatch("124",+"%5E[0-9]%2B$",+RegexOptions.Compiled)|code-block|syntax|javascript|2937341|int.Parse或int.TryParse并不总是有效的，因为字符串可能包含整数可以容纳的更多数字。|offset|length|style|CODE|2937342|如果您要多次执行此检查，则使用已编译的正则表达式是有用的-第一次需要更多时间，但之后会快得多。|2937343|entityMap^0|0|0|0|9|A|C|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

This should work:

<pre><code>Regex.IsMatch("124", "^[0-9]+$", RegexOptions.Compiled)
</code></pre>

<code>int.Parse</code> or <code>int.TryParse</code> won't always work, because the string might contain more digits that an int can hold.

If you are going to do this check more than once it is useful to use a compiled regex - it takes more time the first time, but is much faster after that.

blocks|key|2937354|text|bool+IsDigitsOnly(string+str)
{
++++foreach+(char+c+in+str)
++++{
++++++++if+(c+<+'0'+%7C%7C+c+>+'9')
++++++++++++return+false;
++++}

++++return+true;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2937355|可能是最快的方法。|unstyled|2937356|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>bool IsDigitsOnly(string str)
{
 foreach (char c in str)
 {
 if (c &lt; '0' || c &gt; '9')
 return false;
 }

 return true;
}
</code></pre>

Will probably be the fastest way to do it.

blocks|key|2937369|text|以下是基于同一字符串的1000000次解析的一些基准测试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937370|更新了release统计信息：|offset|length|style|CODE|2937371|IsDigitsOnly:+384588
TryParse:+++++639583
Regex:++++++++1329571|code-block|syntax|javascript|2937372|下面是代码，看起来IsDigitsOnly更快：|2937373|class+Program
{
++++private+static+Regex+regex+=+new+Regex("%5E[0-9]%2B$",+RegexOptions.Compiled);

++++static+void+Main(string[]+args)
++++{
++++++++Stopwatch+watch+=+new+Stopwatch();
++++++++string+test+=+int.MaxValue.ToString();
++++++++int+value;

++++++++watch.Start();
++++++++for(int+i=0;+i<+1000000;+i%2B%2B)
++++++++{
++++++++++++int.TryParse(test,+out+value);
++++++++}
++++++++watch.Stop();
++++++++Console.WriteLine("TryParse:+"%2Bwatch.ElapsedTicks);

++++++++watch.Reset();
++++++++watch.Start();
++++++++for+(int+i+=+0;+i+<+1000000;+i%2B%2B)
++++++++{
++++++++++++IsDigitsOnly(test);
++++++++}
++++++++watch.Stop();
++++++++Console.WriteLine("IsDigitsOnly:+"+%2B+watch.ElapsedTicks);

++++++++watch.Reset();
++++++++watch.Start();
++++++++for+(int+i+=+0;+i+<+1000000;+i%2B%2B)
++++++++{
++++++++++++regex.IsMatch(test);
++++++++}
++++++++watch.Stop();
++++++++Console.WriteLine("Regex:+"+%2B+watch.ElapsedTicks);

++++++++Console.ReadLine();
++++}

++++static+bool+IsDigitsOnly(string+str)
++++{
++++++++foreach+(char+c+in+str)
++++++++{
++++++++++++if+(c+<+'0'+%7C%7C+c+>+'9')
++++++++++++++++return+false;
++++++++}

++++++++return+true;
++++}
}|2937374|当然，值得注意的是，TryParse确实允许前导/尾随空格以及特定于文化的符号。它也受到字符串长度的限制。|2937375|entityMap^0|0|3|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Here's some benchmarks based on 1000000 parses of the same string:

Updated for <code>release</code> stats:

<pre><code>IsDigitsOnly: 384588
TryParse: 639583
Regex: 1329571
</code></pre>

Here's the code, looks like IsDigitsOnly is faster:

<pre><code>class Program
{
 private static Regex regex = new Regex("^[0-9]+$", RegexOptions.Compiled);

 static void Main(string[] args)
 {
 Stopwatch watch = new Stopwatch();
 string test = int.MaxValue.ToString();
 int value;

 watch.Start();
 for(int i=0; i&lt; 1000000; i++)
 {
 int.TryParse(test, out value);
 }
 watch.Stop();
 Console.WriteLine("TryParse: "+watch.ElapsedTicks);

 watch.Reset();
 watch.Start();
 for (int i = 0; i &lt; 1000000; i++)
 {
 IsDigitsOnly(test);
 }
 watch.Stop();
 Console.WriteLine("IsDigitsOnly: " + watch.ElapsedTicks);

 watch.Reset();
 watch.Start();
 for (int i = 0; i &lt; 1000000; i++)
 {
 regex.IsMatch(test);
 }
 watch.Stop();
 Console.WriteLine("Regex: " + watch.ElapsedTicks);

 Console.ReadLine();
 }

 static bool IsDigitsOnly(string str)
 {
 foreach (char c in str)
 {
 if (c &lt; '0' || c &gt; '9')
 return false;
 }

 return true;
 }
}
</code></pre>

Of course it's worth noting that TryParse does allow leading/trailing whitespace as well as culture specific symbols. It's also limited on length of string.

blocks|key|253632|text|如果您关心性能，请不要使用int.TryParse或Regex+-编写您自己的(简单)函数(下面是DigitsOnly或DigitsOnly2，但而不是+DigitsOnly3+-+LINQ似乎会产生很大的开销)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|253633|此外，请注意，如果字符串太长而无法“容纳”到int中，则int.TryParse将失败。|253634|这个简单的基准测试。|253635|class+Program+{

++++static+bool+DigitsOnly(string+s)+{
++++++++int+len+=+s.Length;
++++++++for+(int+i+=+0;+i+<+len;+%2B%2Bi)+{
++++++++++++char+c+=+s[i];
++++++++++++if+(c+<+'0'+%7C%7C+c+>+'9')
++++++++++++++++return+false;
++++++++}
++++++++return+true;
++++}

++++static+bool+DigitsOnly2(string+s)+{
++++++++foreach+(char+c+in+s)+{
++++++++++++if+(c+<+'0'+%7C%7C+c+>+'9')
++++++++++++++++return+false;
++++++++}
++++++++return+true;
++++}

++++static+bool+DigitsOnly3(string+s)+{
++++++++return+s.All(c+=>+c+>=+'0'+&&+c+<=+'9');
++++}

++++static+void+Main(string[]+args)+{

++++++++const+string+s1+=+"916734184";
++++++++const+string+s2+=+"916734a84";

++++++++const+int+iterations+=+1000000;
++++++++var+sw+=+new+Stopwatch();

++++++++sw.Restart();
++++++++for+(int+i+=+0+;+i+<+iterations;+%2B%2Bi)+{
++++++++++++bool+success+=+DigitsOnly(s1);
++++++++++++bool+failure+=+DigitsOnly(s2);
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(string.Format("DigitsOnly:+{0}",+sw.Elapsed));

++++++++sw.Restart();
++++++++for+(int+i+=+0;+i+<+iterations;+%2B%2Bi)+{
++++++++++++bool+success+=+DigitsOnly2(s1);
++++++++++++bool+failure+=+DigitsOnly2(s2);
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(string.Format("DigitsOnly2:+{0}",+sw.Elapsed));

++++++++sw.Restart();
++++++++for+(int+i+=+0;+i+<+iterations;+%2B%2Bi)+{
++++++++++++bool+success+=+DigitsOnly3(s1);
++++++++++++bool+failure+=+DigitsOnly3(s2);
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(string.Format("DigitsOnly3:+{0}",+sw.Elapsed));

++++++++sw.Restart();
++++++++for+(int+i+=+0;+i+<+iterations;+%2B%2Bi)+{
++++++++++++int+dummy;
++++++++++++bool+success+=+int.TryParse(s1,+out+dummy);
++++++++++++bool+failure+=+int.TryParse(s2,+out+dummy);
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(string.Format("int.TryParse:+{0}",+sw.Elapsed));

++++++++sw.Restart();
++++++++var+regex+=+new+Regex("%5E[0-9]%2B$",+RegexOptions.Compiled);
++++++++for+(int+i+=+0;+i+<+iterations;+%2B%2Bi)+{
++++++++++++bool+success+=+regex.IsMatch(s1);
++++++++++++bool+failure+=+regex.IsMatch(s2);
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(string.Format("Regex.IsMatch:+{0}",+sw.Elapsed));

++++}

}|code-block|syntax|javascript|253636|...produces下面的结果...|253637|DigitsOnly:+00:00:00.0346094
DigitsOnly2:+00:00:00.0365220
DigitsOnly3:+00:00:00.2669425
int.TryParse:+00:00:00.3405548
Regex.IsMatch:+00:00:00.7017648|253638|entityMap^0|D|C|Q|5|1D|A|1O|B|25|B|21|3|0|M|3|S|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|E|@]|F|$]]|$1|I|3|J|5|6|7|1D|8|@]|E|@]|F|$]]|$1|K|3|L|5|M|7|1E|8|@]|E|@]|F|$N|O]]|$1|P|3|Q|5|6|7|1F|8|@]|E|@]|F|$]]|$1|R|3|S|5|M|7|1G|8|@]|E|@]|F|$N|O]]|$1|T|3|-4|5|6|7|1H|8|@]|E|@]|F|$]]]|U|$]]

If you are concerned about performance, use neither <code>int.TryParse</code> nor <code>Regex</code> - write your own (simple) function (<code>DigitsOnly</code> or <code>DigitsOnly2</code> below, but not <code>DigitsOnly3</code> - LINQ seems to incur a significant overhead).

Also, be aware that <code>int.TryParse</code> will fail if the string is too long to "fit" into <code>int</code>.

This simple benchmark...

<pre><code>class Program {

 static bool DigitsOnly(string s) {
 int len = s.Length;
 for (int i = 0; i &lt; len; ++i) {
 char c = s[i];
 if (c &lt; '0' || c &gt; '9')
 return false;
 }
 return true;
 }

 static bool DigitsOnly2(string s) {
 foreach (char c in s) {
 if (c &lt; '0' || c &gt; '9')
 return false;
 }
 return true;
 }

 static bool DigitsOnly3(string s) {
 return s.All(c =&gt; c &gt;= '0' &amp;&amp; c &lt;= '9');
 }

 static void Main(string[] args) {

 const string s1 = "916734184";
 const string s2 = "916734a84";

 const int iterations = 1000000;
 var sw = new Stopwatch();

 sw.Restart();
 for (int i = 0 ; i &lt; iterations; ++i) {
 bool success = DigitsOnly(s1);
 bool failure = DigitsOnly(s2);
 }
 sw.Stop();
 Console.WriteLine(string.Format("DigitsOnly: {0}", sw.Elapsed));

 sw.Restart();
 for (int i = 0; i &lt; iterations; ++i) {
 bool success = DigitsOnly2(s1);
 bool failure = DigitsOnly2(s2);
 }
 sw.Stop();
 Console.WriteLine(string.Format("DigitsOnly2: {0}", sw.Elapsed));

 sw.Restart();
 for (int i = 0; i &lt; iterations; ++i) {
 bool success = DigitsOnly3(s1);
 bool failure = DigitsOnly3(s2);
 }
 sw.Stop();
 Console.WriteLine(string.Format("DigitsOnly3: {0}", sw.Elapsed));

 sw.Restart();
 for (int i = 0; i &lt; iterations; ++i) {
 int dummy;
 bool success = int.TryParse(s1, out dummy);
 bool failure = int.TryParse(s2, out dummy);
 }
 sw.Stop();
 Console.WriteLine(string.Format("int.TryParse: {0}", sw.Elapsed));

 sw.Restart();
 var regex = new Regex("^[0-9]+$", RegexOptions.Compiled);
 for (int i = 0; i &lt; iterations; ++i) {
 bool success = regex.IsMatch(s1);
 bool failure = regex.IsMatch(s2);
 }
 sw.Stop();
 Console.WriteLine(string.Format("Regex.IsMatch: {0}", sw.Elapsed));

 }

}
</code></pre>

...produces the following result...

<pre><code>DigitsOnly: 00:00:00.0346094
DigitsOnly2: 00:00:00.0365220
DigitsOnly3: 00:00:00.2669425
int.TryParse: 00:00:00.3405548
Regex.IsMatch: 00:00:00.7017648
</code></pre>

blocks|key|257030|text|char已经有了一个IsDigit(char+c)，它执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|257031|+public+static+bool+IsDigit(char+c)
++++{
++++++if+(!char.IsLatin1(c))
++++++++return+CharUnicodeInfo.GetUnicodeCategory(c)+==+UnicodeCategory.DecimalDigitNumber;
++++++if+((int)+c+>=+48)
++++++++return+(int)+c+<=+57;
++++++else
++++++++return+false;
++++}|code-block|syntax|javascript|257032|您可以简单地执行以下操作：|257033|var+theString+=+"839278";
bool+digitsOnly+=+theString.All(char.IsDigit);|257034|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The char already has an IsDigit(char c) which does this:

<pre><code> public static bool IsDigit(char c)
 {
 if (!char.IsLatin1(c))
 return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.DecimalDigitNumber;
 if ((int) c &gt;= 48)
 return (int) c &lt;= 57;
 else
 return false;
 }
</code></pre>

You can simply do this:

<pre><code>var theString = "839278";
bool digitsOnly = theString.All(char.IsDigit);
</code></pre>

blocks|key|251993|text|您可以在一行LINQ语句中完成此操作。好吧，我意识到这不一定是最快的，所以从技术上讲并没有回答这个问题，但它可能是最容易编写的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|251994|str.All(c+=>+c+>=+'0'+&&+c+<=+'9')|code-block|syntax|javascript|251995|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can do this in a one line LINQ statement. OK, I realise this is not necessarily the fastest, so doesn't technically answer the question, but it's probably the easiest to write:

<pre><code>str.All(c =&gt; c &gt;= '0' &amp;&amp; c &lt;= '9')
</code></pre>

blocks|key|3151727|text|您可以尝试使用正则表达式，方法是使用C#中的.IsMatch(string+input,+string+pattern)方法将输入字符串测试为只有数字(0-9)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3151728|using+System;
using+System.Text.RegularExpression;

public+namespace+MyNS
{
++++public+class+MyClass
++++{
++++++++public+void+static+Main(string[]+args)
++++++++{
+++++++++++++string+input+=+Console.ReadLine();
+++++++++++++bool+containsNumber+=+ContainsOnlyDigits(input);
++++++++}

++++++++private+bool+ContainOnlyDigits+(string+input)
++++++++{
++++++++++++bool+containsNumbers+=+true;
++++++++++++if+(!Regex.IsMatch(input,+@"/d"))
++++++++++++{
++++++++++++++++containsNumbers+=+false;
++++++++++++}
++++++++++++return+containsNumbers;
++++++++}
++++}
}|code-block|syntax|javascript|3151729|问候|3151730|entityMap^0|M|12|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

You can try using Regular Expressions by testing the input string to have only digits (0-9) by using the <code>.IsMatch(string input, string pattern)</code> method in C#.

<pre><code>using System;
using System.Text.RegularExpression;

public namespace MyNS
{
 public class MyClass
 {
 public void static Main(string[] args)
 {
 string input = Console.ReadLine();
 bool containsNumber = ContainsOnlyDigits(input);
 }

 private bool ContainOnlyDigits (string input)
 {
 bool containsNumbers = true;
 if (!Regex.IsMatch(input, @"/d"))
 {
 containsNumbers = false;
 }
 return containsNumbers;
 }
 }
}
</code></pre>

Regards

blocks|key|3151739|text|我喜欢Linq，要让它在第一次不匹配时退出，你可以这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3151740|string+str+=+'0129834X33';
bool+isAllDigits+=+!str.Any(+ch=>+ch+<+'0'+%7C%7C+ch+>+'9'+);|code-block|syntax|javascript|3151741|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like Linq and to make it exit on first mismatch you can do this 

<pre><code>string str = '0129834X33';
bool isAllDigits = !str.Any( ch=&gt; ch &lt; '0' || ch &gt; '9' );
</code></pre>

blocks|key|257054|text|那char.IsDigit(myChar)呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|257055|entityMap^0|1|K|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

What about <code>char.IsDigit(myChar)</code>?

blocks|key|2937458|text|您可以简单地使用LINQ来完成此操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937459|return+str.All(char.IsDigit);|offset|length|style|CODE|2937460|对于空字符串，|2937461|.All返回true，对于所有Unicode字符，如果strings.|ordered-list-item|2937462|char.IsDigit为空，则返回exception。|2937463|2937464|entityMap^0|0|0|T|0|0|0|4|0|0|C|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|M|3|N|5|L|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|Q|$]]

You could simply do this using LINQ

<code>return str.All(char.IsDigit);</code>

<ol>
<li><code>.All</code> returns true for empty strings and exception for null strings.</li>
<li><code>char.IsDigit</code> is true for all Unicode characters.</li>
</ol>

blocks|key|2937466|text|通过对每个char和for而不是foreach使用一次比较，可以将速度提高约20%25|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2937467|bool+isDigits(string+s)+
{+
++++if+(s+==+null+%7C%7C+s+==+"")+return+false;+

++++for+(int+i+=+0;+i+<+s.Length;+i%2B%2B)+
++++++++if+((s[i]+%5E+'0')+>+9)+
++++++++++++return+false;+

++++return+true;+
}|code-block|syntax|javascript|2937468|2937469|用于测试的代码(总是配置文件，因为结果取决于硬件、版本、顺序等)：|2937470|static+bool+isDigitsFr(string+s)+{+if+(s+==+null+%7C%7C+s+==+"")+return+false;+for+(int+i+=+0;+i+<+s.Length;+i%2B%2B)+if+(s[i]+<+'0'+%7C%7C+s[i]+>+'9')+return+false;+return+true;+}
static+bool+isDigitsFu(string+s)+{+if+(s+==+null+%7C%7C+s+==+"")+return+false;+for+(int+i+=+0;+i+<+s.Length;+i%2B%2B)+if+((uint)(s[i]+-+'0')+>+9)+return+false;+return+true;+}
static+bool+isDigitsFx(string+s)+{+if+(s+==+null+%7C%7C+s+==+"")+return+false;+for+(int+i+=+0;+i+<+s.Length;+i%2B%2B)+if+((s[i]+%5E+'0')+>+9)+return+false;+return+true;+}
static+bool+isDigitsEr(string+s)+{+if+(s+==+null+%7C%7C+s+==+"")+return+false;+foreach+(char+c+in+s)+if+(c+<+'0'+%7C%7C+c+>+'9')+return+false;+return+true;+}
static+bool+isDigitsEu(string+s)+{+if+(s+==+null+%7C%7C+s+==+"")+return+false;+foreach+(char+c+in+s)+if+((uint)(c+-+'0')+>+9)+return+false;+return+true;+}
static+bool+isDigitsEx(string+s)+{+if+(s+==+null+%7C%7C+s+==+"")+return+false;+foreach+(char+c+in+s)+if+((c+%5E+'0')+>+9)+return+false;+return+true;+}
static+void+test()
{
++++var+w+=+new+Stopwatch();+bool+b;+var+s+=+int.MaxValue+%2B+"";+int+r+=+12345678*2;+var+ss+=+new+SortedSet<string>();+//s+=+string.Concat(Enumerable.Range(0,+127).Select(i+=>+((char)i+%5E+'0')+<+10+?+1+:+0));
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+s.All(char.IsDigit);+w.Stop();+ss.Add(w.Elapsed+%2B+".All+.IsDigit");+
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+s.All(c+=>+c+>=+'0'+&&+c+<=+'9');+w.Stop();+ss.Add(w.Elapsed+%2B+".All+<>");+
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+s.All(c+=>+(c+%5E+'0')+<+10);+w.Stop();+ss.Add(w.Elapsed+%2B+"+.All+%5E");+
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+isDigitsFr(s);+w.Stop();+ss.Add(w.Elapsed+%2B+"+for+++++<>");
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+isDigitsFu(s);+w.Stop();+ss.Add(w.Elapsed+%2B+"+for+++++-");
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+isDigitsFx(s);+w.Stop();+ss.Add(w.Elapsed+%2B+"+for+++++%5E");
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+isDigitsEr(s);+w.Stop();+ss.Add(w.Elapsed+%2B+"+foreach+<>");
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+isDigitsEu(s);+w.Stop();+ss.Add(w.Elapsed+%2B+"+foreach+-");
++++w.Restart();+for+(int+i+=+0;+i+<+r;+i%2B%2B)+b+=+isDigitsEx(s);+w.Stop();+ss.Add(w.Elapsed+%2B+"+foreach+%5E");
++++MessageBox.Show(string.Join("\n",+ss));+return;
}|2937471|在英特尔i5-3470+@3.2+and、VS+2015+.NET+4.6.1发布模式和启用的优化上的结果：|2937472|time++++method++++++++++ratio
0.7776++for+++++%5E+++++++1.0000+
0.7984++foreach+-+++++++1.0268+
0.8066++foreach+%5E+++++++1.0372+
0.8940++for+++++-+++++++1.1497+
0.8976++for+++++<>++++++1.1543+
0.9456++foreach+<>++++++1.2160+
4.4559++.All+<>+++++++++5.7303+
4.7791++.All+%5E++++++++++6.1458+
4.8539++.All.+IsDigit+++6.2421+|2937473|2937474|对于任何想要使用较短方法的人，请注意|2937475|对于所有|2937476|.All，strings|unordered-list-item|2937477|char.IsDigit都为真还允许使用空格和符号字符|2937478|2937479|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/bb548541|1|https://msdn.microsoft.com/en-us/library/0t641e58^0|5|4|A|3|G|7|0|0|0|0|0|0|0|0|0|0|0|4|0|4|0|0|0|C|0|C|1|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1N|8|@]|D|@]|E|$]]|$1|N|3|O|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|P|3|Q|5|6|7|1P|8|@]|D|@]|E|$]]|$1|R|3|S|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|T|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1S|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1T|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|10|7|1U|8|@$9|1V|A|1W|B|C]]|D|@$9|1X|A|1Y|1|1Z]]|E|$]]|$1|11|3|12|5|10|7|20|8|@$9|21|A|22|B|C]]|D|@$9|23|A|24|1|25]]|E|$]]|$1|13|3|-4|5|6|7|26|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|27|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]|1C|$5|17|18|19|E|$1A|1D]]]]

Can be about 20% faster by using just one comparison per <code>char</code> and <code>for</code> instead of <code>foreach</code>:

<pre><code>bool isDigits(string s) 
{ 
 if (s == null || s == "") return false; 

 for (int i = 0; i &lt; s.Length; i++) 
 if ((s[i] ^ '0') &gt; 9) 
 return false; 

 return true; 
}
</code></pre>

<hr>

Code used for testing (always profile because the results depend on hardware, versions, order, etc.):

<pre><code>static bool isDigitsFr(string s) { if (s == null || s == "") return false; for (int i = 0; i &lt; s.Length; i++) if (s[i] &lt; '0' || s[i] &gt; '9') return false; return true; }
static bool isDigitsFu(string s) { if (s == null || s == "") return false; for (int i = 0; i &lt; s.Length; i++) if ((uint)(s[i] - '0') &gt; 9) return false; return true; }
static bool isDigitsFx(string s) { if (s == null || s == "") return false; for (int i = 0; i &lt; s.Length; i++) if ((s[i] ^ '0') &gt; 9) return false; return true; }
static bool isDigitsEr(string s) { if (s == null || s == "") return false; foreach (char c in s) if (c &lt; '0' || c &gt; '9') return false; return true; }
static bool isDigitsEu(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((uint)(c - '0') &gt; 9) return false; return true; }
static bool isDigitsEx(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((c ^ '0') &gt; 9) return false; return true; }
static void test()
{
 var w = new Stopwatch(); bool b; var s = int.MaxValue + ""; int r = 12345678*2; var ss = new SortedSet&lt;string&gt;(); //s = string.Concat(Enumerable.Range(0, 127).Select(i =&gt; ((char)i ^ '0') &lt; 10 ? 1 : 0));
 w.Restart(); for (int i = 0; i &lt; r; i++) b = s.All(char.IsDigit); w.Stop(); ss.Add(w.Elapsed + ".All .IsDigit"); 
 w.Restart(); for (int i = 0; i &lt; r; i++) b = s.All(c =&gt; c &gt;= '0' &amp;&amp; c &lt;= '9'); w.Stop(); ss.Add(w.Elapsed + ".All &lt;&gt;"); 
 w.Restart(); for (int i = 0; i &lt; r; i++) b = s.All(c =&gt; (c ^ '0') &lt; 10); w.Stop(); ss.Add(w.Elapsed + " .All ^"); 
 w.Restart(); for (int i = 0; i &lt; r; i++) b = isDigitsFr(s); w.Stop(); ss.Add(w.Elapsed + " for &lt;&gt;");
 w.Restart(); for (int i = 0; i &lt; r; i++) b = isDigitsFu(s); w.Stop(); ss.Add(w.Elapsed + " for -");
 w.Restart(); for (int i = 0; i &lt; r; i++) b = isDigitsFx(s); w.Stop(); ss.Add(w.Elapsed + " for ^");
 w.Restart(); for (int i = 0; i &lt; r; i++) b = isDigitsEr(s); w.Stop(); ss.Add(w.Elapsed + " foreach &lt;&gt;");
 w.Restart(); for (int i = 0; i &lt; r; i++) b = isDigitsEu(s); w.Stop(); ss.Add(w.Elapsed + " foreach -");
 w.Restart(); for (int i = 0; i &lt; r; i++) b = isDigitsEx(s); w.Stop(); ss.Add(w.Elapsed + " foreach ^");
 MessageBox.Show(string.Join("\n", ss)); return;
}
</code></pre>

Results on Intel i5-3470 @ 3.2GHz, VS 2015 .NET 4.6.1 Release mode and optimizations enabled:

<pre><code>time method ratio
0.7776 for ^ 1.0000 
0.7984 foreach - 1.0268 
0.8066 foreach ^ 1.0372 
0.8940 for - 1.1497 
0.8976 for &lt;&gt; 1.1543 
0.9456 foreach &lt;&gt; 1.2160 
4.4559 .All &lt;&gt; 5.7303 
4.7791 .All ^ 6.1458 
4.8539 .All. IsDigit 6.2421 
</code></pre>

<hr>

For anyone tempted to use the shorter methods, note that 

<ul>
<li><a href="https://msdn.microsoft.com/en-us/library/bb548541" rel="noreferrer"><code>.All</code></a> results in <a href="https://referencesource.microsoft.com/#System.Core/System/Linq/Enumerable.cs,be4bfd025bd2724c" rel="noreferrer"><code>true</code> for empty strings</a> and exception for <code>null</code> strings</li>
<li><a href="https://msdn.microsoft.com/en-us/library/0t641e58" rel="noreferrer"><code>char.IsDigit</code></a> is true for all <a href="http://www.fileformat.info/info/unicode/category/Nd/list.htm" rel="noreferrer">Unicode characters in the Nd category</a></li>
<li><a href="https://msdn.microsoft.com/en-us/library/f02979c7" rel="noreferrer"><code>int.TryParse</code></a> also allows white spase and sign characters</li>
</ul>

blocks|key|3151787|text|这将完美地工作，还有许多其他方法，但这将工作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3151788|bool+IsDigitsOnly(string+str)
++++{
++++++++if+(str.Length+>+0)//if+contains+characters
++++++++{
++++++++++++foreach+(char+c+in+str)//assign+character+to+c
++++++++++++{
++++++++++++++++if+(c+<+'0'+%7C%7C+c+>+'9')//check+if+its+outside+digit+range
++++++++++++++++++++return+false;
++++++++++++}
++++++++}else//empty+string
++++++++{
++++++++++++return+false;//empty+string+
++++++++}

++++++++return+true;//only+digits
++++}|code-block|syntax|javascript|3151789|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

this will work perfectly, there is many other ways but this would work

<pre><code>bool IsDigitsOnly(string str)
 {
 if (str.Length &gt; 0)//if contains characters
 {
 foreach (char c in str)//assign character to c
 {
 if (c &lt; '0' || c &gt; '9')//check if its outside digit range
 return false;
 }
 }else//empty string
 {
 return false;//empty string 
 }

 return true;//only digits
 }
</code></pre>

blocks|key|253709|text|非常聪明和简单的方法来检测你的字符串是否只包含数字是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|253710|string+s+=+"12fg";

if(s.All(char.IsDigit))
{
+++return+true;+//+contains+only+digits
}
else
{
+++return+false;+//+contains+not+only+digits
}|code-block|syntax|javascript|253711|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Very Clever and easy way to detect your string is contains only digits or not is this way:

<pre><code>string s = "12fg";

if(s.All(char.IsDigit))
{
 return true; // contains only digits
}
else
{
 return false; // contains not only digits
}
</code></pre>

blocks|key|252106|text|可能最快的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|252107|myString.All(c+=>+char.IsDigit(c))|code-block|syntax|javascript|252108|注意：如果字符串是空的，它将返回True，这是不正确的(如果您不认为空是有效的数字/数字)|offset|length|style|BOLD|252109|entityMap^0|0|0|0|3|G|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Probably the fastest way is:

<pre><code>myString.All(c =&gt; char.IsDigit(c))
</code></pre>

Note: it will return True in case your string is empty which is incorrect (if you not considering empty as valid number/digit )

blocks|key|2937517|text|尝试以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937518|bool+isDigitsOnly(string+str)
{
+++try
+++{
++++++int+number+=+Convert.ToInt32(str);
++++++return+true;
+++}
+++catch+(Exception)
+++{
++++++return+false;
+++}
}|code-block|syntax|javascript|2937519|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this code:

<pre><code>bool isDigitsOnly(string str)
{
 try
 {
 int number = Convert.ToInt32(str);
 return true;
 }
 catch (Exception)
 {
 return false;
 }
}
</code></pre>

blocks|key|2937521|text|public+bool+CheckforDigits(string+x)
{++++
++++int+tr;++
++++return+x.All(r=>+int.TryParse(r.ToString(),+out+tr));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2937522|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public bool CheckforDigits(string x)
{ 
 int tr; 
 return x.All(r=&gt; int.TryParse(r.ToString(), out tr));
}
</code></pre>

blocks|key|2937599|text|这可能来得太晚了！但我相信它会帮助一些人，就像它帮助了我一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937600|++++++++private+static+bool+IsDigitsOnly(string+str)
++++++++{
++++++++++++return+str.All(c+=>+c+>=+'0'+&&+c+<=+'9');
++++++++}|code-block|syntax|javascript|2937601|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This might be coming super late!, but I'm sure it will help someone, as it helped me.

<pre><code> private static bool IsDigitsOnly(string str)
 {
 return str.All(c =&gt; c &gt;= '0' &amp;&amp; c &lt;= '9');
 }
</code></pre>

blocks|key|3152018|text|验证为空的函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3152019|public+static+bool+IsDigitsOnly(string+str)
++{+++++++++++++
++++++++return+!string.IsNullOrEmpty(str)+&&+str.All(char.IsDigit);
++}|code-block|syntax|javascript|3152020|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Function with empty validation:

<pre><code>public static bool IsDigitsOnly(string str)
 { 
 return !string.IsNullOrEmpty(str) &amp;&amp; str.All(char.IsDigit);
 }
</code></pre>

blocks|key|3152026|text|如果是单个字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3152027|if+(str.All(Char.IsDigit))
{
++//+string+contains+only+digits
}|code-block|syntax|javascript|3152028|如果它是一个字符串列表：|3152029|if+(lstStr.All(s+=>+s.All(Char.IsDigit)))
{
++//+List+of+strings+contains+only+digits
}|3152030|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

if it is a single string :
<pre><code>if (str.All(Char.IsDigit))
{
 // string contains only digits
}
</code></pre>
if it is a list of strings :
<pre><code>if (lstStr.All(s =&gt; s.All(Char.IsDigit)))
{
 // List of strings contains only digits
}
</code></pre>

blocks|key|3152035|text|另一种方法！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3152036|string+str+=+"12345";
bool+containsOnlyDigits+=+true;
try+{+if(Convert.ToInt32(str)+<+0){+containsOnlyDigits+=+false;+}+}
catch+{+containsOnlyDigits+=+false;+}|code-block|syntax|javascript|3152037|在这里，如果语句Convert.ToInt32(str)失败，则字符串不只包含数字。另一种可能是，如果字符串包含成功转换为-12345的"-12345"，则需要检查转换后的数字是否不小于零。|offset|length|style|CODE|3152038|entityMap^0|0|0|8|K|1P|6|1W|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

Another approach!
<pre><code>string str = &quot;12345&quot;;
bool containsOnlyDigits = true;
try { if(Convert.ToInt32(str) &lt; 0){ containsOnlyDigits = false; } }
catch { containsOnlyDigits = false; }
</code></pre>
Here, if the statement <code>Convert.ToInt32(str)</code> fails, then string does not contain digits only. Another possibility is that if the string has <code>&quot;-12345&quot;</code> which gets converted to <code>-12345</code> successfully, then there is a check for verifying that the number converted is not less than zero.

I know a few ways how to check this.
regex,<code>int.parse</code>,<code>tryparse</code>,looping.

can anyone tell me what is the fastest way to check?

the need is to only CHECK no need to actually parse.

this is not the same question as: <a href="https://stackoverflow.com/questions/894263/how-do-i-identify-if-a-string-is-a-number">How do I identify if a string is a number?</a>

the question is not only about how identify.
but about what is the fastest method.

Fastest way to check if string contains only digits

我知道几种方法来检查这个。正则表达式、int.parse、tryparse、循环。谁能告诉我检查最快的方法是什么？需要的是只对进行检查，不需要实际解析。这与以下问题不同：问题不仅仅是如何识别。但是关于什么是最快的方法。

问检查字符串是否只包含数字的最快方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查字符串是否只包含数字的最快方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查字符串是否只包含数字的最快方法
EN