## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

No credit card required

# 1.8. Determining Whether a String Is a Valid Number

## Problem

You have a string that possibly contains a numeric value. You need to know whether this string contains a valid number.

## Solution

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

## Discussion

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.

## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, interactive tutorials, and more.

No credit card required