You have a string that possibly contains a numeric value. You need to know whether this string contains a valid number.
Use the static Parse
method of any of the numeric types. For example, to determine whether
a string contains an integer, use the following
method:
public static bool IsNumeric(string str) { try { str = str.Trim( ); int foo = int.Parse(str); return (true); } catch (FormatException) { // Not a numeric value return (false); } }
If you instead needed to test whether a string is a floating-point
value, change the second line in the try
block to
the following:
int foo = float.Parse(str);
A more
compact way of testing a string for a numeric value—and one
that does not have the overhead of throwing an exception—is to
use the double.TryParse
method:
public static bool IsNumericFromTryParse(string str) { double result = 0; return (double.TryParse(str, System.Globalization.NumberStyles.Float, System.Globalization.NumberFormatInfo.CurrentInfo, out result)); }
The
following IsNumericRegEx
method does not incur the
overhead of throwing an exception and it allows more flexibility in
determining what type of number to test for. The
IsNumericRegEx
method tests for a number that can
be signed/unsigned, contain a decimal point, and be displayed in
scientific notation. This method accepts a string, possibly
containing only a number, and returns true
or
false
, depending on whether this string conforms
to a numeric value:
private static Regex r = new Regex(@"^[+-]?d*.?[Ee]?[+-]?d*$", RegexOptions.Compiled); public static bool IsNumericRegEx(string str) { str = str.Trim( ); Match m = r.Match(str); return (m.Value); }
This recipe shows three ways of determining whether a string contains
only a numeric value. The IsNumeric
method uses
the Parse
method, which throws a
FormatException
if
the string cannot be converted to the appropriate type. The second
method, IsNumericFromTryParse
, uses the built-in
double.TryParse
method; this method also returns a
value of type double
if the string contains a
valid number. The third method, IsNumericRegEx
,
uses a regular expression to determine whether the value of a string
conforms to the various formats of a numeric value, such as an
integer, a floating-point value, or a number written in scientific
notation.
The method you choose can have a performance impact on your
application. It’s not just a question of whether
it’s called many times, it’s also
about whether a valid number exists within the string passed in to
these methods. In some scenarios IsNumeric
will be
fastest, even if you call it many times. In others, the
IsNumericFromTryParse
or
IsNumericRegEx
will be fastest. It all depends on
how often the string will not be a valid number. If you expect the
string to contain non-numeric data most of the time (or even half the
time), you should consider using the
IsNumericFromTryParse
or
IsNumericRegEx
methods. Otherwise, the
IsNumeric
method will give you the best
performance.
The IsNumericRegEx
method uses the static IsMatch
method on the
Regex
class to attempt to match a numeric value
contained in the string str
. This static method
returns true
if the match succeeds and
false
if it does not. Notice also that the regular
expression starts with the ^
character and ends
with the $
character. This forces the regular
expression to match everything within the string, not just part of
the string. If these characters were not included, the
IsMatch
method would return
true
for the following string "111 West Ave
“.
The IsNumericRegEx
method has a drawback: it
cannot determine the data type of the number contained within the
string. For example, the int.Parse
method will
accept only strings that contain a valid integer value; likewise, the
float.Parse
method will accept only strings
containing valid float
values. The regular
expression will return true
for any type of
numeric value matched. To enhance the regular expression, use the
following method to determine whether a value is a non-floating-point
number:
public static bool IsIntegerRegEx(string str) { str = str.Trim( ); return (Regex.IsMatch(str, @"^[+-]?d+$")); }
We could also use the following method to determine whether the string contains an unsigned number:
public static bool IsUnsignedIntegerRegEx(string str) { str = str.Trim( ); return (Regex.IsMatch(str, @"^+?d+$")); }
Note also that the Trim
method can be excluded if
you want to find numbers within strings that contain no beginning or
ending whitespace.