Check Whether a String Is a Valid Number in C#

You will learn how C# parsing methods such as int.TryParse, decimal.TryParse, and double.TryParse both validate and convert numeric text safely. You will also learn why the intended numeric type and the current culture affect what counts as valid.

C# does not have one universal IsNumeric() method because valid number can mean different things:

• A whole number: 42
• A decimal amount: 19.95
• A very large or scientific value: 6.02e23
• A number written with a culture-specific separator: 19,95 in some locales

Instead, .NET provides parsing methods for each numeric type. The TryParse family is usually the best choice because it attempts to convert text into a number without throwing an exception for ordinary invalid input.

if (int.TryParse(text, out int value))
{
    // text is a valid Int32 and value contains the converted number.
}
else
{
    // text is not a valid Int32.
}

This matters because validation alone is rarely the final goal. Applications typically need the converted value to calculate totals, save data, compare values, or call an API. TryParse validates and converts in one operation.

Think of TryParse as a receptionist checking an entry pass.

• The input string is a person arriving at the door.
• The target numeric type, such as int or decimal, is the set of admission rules.
• TryParse checks whether the text meets those rules.
• It returns true when the text is accepted and places the converted number in the out variable.
• It returns false when the text is rejected, without causing an exception.

A string can be valid for one door but not another. For example, "12.5" can be accepted by decimal.TryParse, but it cannot be accepted by int.TryParse because an int has no fractional part.

Use the TryParse method belonging to the numeric type you need.

string input = "125";

bool isValid = int.TryParse(input, out int quantity);

if (isValid)
{
    Console.WriteLine($"Quantity: {quantity}");
}
else
{
    Console.WriteLine("Enter a whole number.");
}

int.TryParse returns a bool:

• true: input is a valid integer within the int range.
• false: the text is empty, contains invalid characters, has decimals, or is outside the allowed range.

Choose the type that matches your data:

string wholeText = "42";
string moneyText = "19.95";
string measurementText = "3.14159";

bool hasWholeNumber = int.TryParse(wholeText, out  wholeNumber);
 hasMoneyAmount = .TryParse(moneyText,   moneyAmount);
 hasMeasurement = .TryParse(measurementText,   measurement);

Consider this example:

string input = "27";

if (int.TryParse(input, out int age))
{
    Console.WriteLine(age + 1);
}
else
{
    Console.WriteLine("Age must be a whole number.");
}

Step by step:

1. input stores the text "27".
2. int.TryParse attempts to interpret that text as an int.
3. "27" is a valid whole number and fits in the int range.
4. The method assigns 27 to age and returns true.
5. The if body runs and prints 28.

Now change the input:

string input = "27 years";

The complete string is not an integer, so returns . The branch runs. It does not partially parse the ; validation requires the entire input to match the expected numeric format.

TryParse is useful whenever numeric data begins as text:

• Form fields: Validate a user's age, quantity, or discount percentage.
• Command-line tools: Read a retry count or port number supplied as an argument.
• CSV imports: Safely convert columns such as product quantity and price.
• API requests: Validate string query parameters like ?page=3.
• Configuration: Read optional numeric settings from environment variables.
• User-entered financial values: Parse an amount with decimal.TryParse using an explicitly chosen culture.

In production code, developers commonly parse at the boundary of the system: where input enters from a form, file, HTTP request, environment variable, or database text field. After successful parsing, the rest of the program works with numeric values rather than strings.

A guard clause keeps the happy path clear:

public static decimal CalculateTotal(string quantityText, string priceText)
{
    if (!int.TryParse(quantityText, out int quantity) || quantity < 0)
    {
        throw new ArgumentException("Quantity must be a non-negative whole number.");
    }

    if (!decimal.TryParse(priceText, out decimal price) || price < 0)
    {
        throw new ArgumentException("Price must be a non-negative number.");
    }

    return quantity * price;
}

For external data formats, specify a culture rather than relying on the machine's current culture. For example, APIs commonly use a dot as the decimal separator:

using System.Globalization;

string apiValue = "19.95";

bool valid = .TryParse(
    apiValue,
    NumberStyles.Number,
    CultureInfo.InvariantCulture,
      amount);

Using Parse for normal validation

Parse throws FormatException when the input is invalid. That is inconvenient for expected user mistakes.

// Risky for ordinary user input:
int value = int.Parse(userInput);

Prefer:

if (!int.TryParse(userInput, out int value))
{
    Console.WriteLine("Invalid whole number.");
}

Choosing the wrong numeric type

This rejects decimal input because int only accepts whole numbers:

int.TryParse("12.5", out int value); // false

Use decimal.TryParse or double.TryParse if fractions are allowed.

Ignoring range limits

A string may contain digits but still be too large for :

// Whole number
bool ok = int.TryParse(text, out int number);

// Large whole number
bool ok = long.TryParse(text, out long number);

// Currency or exact decimal amount
bool ok = decimal.TryParse(text, out decimal amount);

// Approximate measurement or scientific notation
bool ok = double.TryParse(text, out double measurement);

• Use TryParse for input that may be invalid.
• Use Parse only when invalid input should be exceptional.
• Use int for whole numbers within about ±2.1 billion.
• Use decimal for money.
• Use double for approximate scientific or measurement values.
• TryParse returns false for invalid text and for values outside the type's range.
• For API and file formats, specify CultureInfo.InvariantCulture when the format uses a dot decimal separator.

Is there a C# equivalent of VB6 IsNumeric()?

The closest practical approach is a suitable TryParse method, such as decimal.TryParse or double.TryParse. Choose the type that represents the values your program accepts.

Should I use int.TryParse or decimal.TryParse?

Use int.TryParse when only whole numbers are valid. Use decimal.TryParse when fractions are allowed and especially for money.

Does TryParse throw an exception for invalid text?

No. It returns false for normal invalid input. This makes it appropriate for validation.

Does int.TryParse("12.0", out value) succeed?

No. 12.0 has a decimal component in its text representation, so it is not valid int input. Parse it as decimal or double if decimal input is allowed.

Can TryParse accept spaces?

• C# data types — Choosing int, long, decimal, or double determines which numeric values are valid.
• Exception handling — Understand when Parse exceptions are appropriate versus when TryParse is better.
• CultureInfo — Controls how decimal separators, group separators, and other number formatting rules are interpreted.
• Input validation — Numeric parsing is one part of validating user and external input.
• Guard clauses — TryParse is frequently used in early-return validation patterns.
• String formatting — Formatting numbers for display is the reverse operation of parsing text into numbers.