How Do I Make a Textbox That Only Accepts Numbers in C#?

Ensuring a textbox only accepts numbers is a common requirement in many C# applications, particularly in forms where numeric input validation is crucial, such as for phone numbers, age, or monetary values. In this article, we’ll explore different methods to create a numeric input textbox in C#, including event handling, regular expressions, and leveraging modern controls.

Why Restrict a Textbox to Numeric Input?

Restricting input in a textbox ensures data integrity and prevents errors at the source. Numeric validation reduces the need for additional error handling in code and improves user experience by guiding them to input the correct type of data.

Using KeyPress Event to Allow Only Numbers

The KeyPress event is one of the most straightforward ways to create a C# textbox numbers only. By handling this event, you can validate user input in real time.

Example Code

📄

private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
{
    // Allow control characters (e.g., backspace)
    if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar))
    {
        e.Handled = true; // Prevent the character from being entered
    }
}

In this example:

• char.IsControl ensures that control characters like Backspace are allowed.
• char.IsDigit validates numeric input.

Using Regular Expressions for Numeric Validation

Regex numeric validation provides a powerful way to restrict input. While it is often used for post-input validation, you can also use it for real-time validation.

Example Code

📄

using System.Text.RegularExpressions;

private void textBox1_TextChanged(object sender, EventArgs e)
{
    Regex regex = new Regex(@"^\d+$");
    if (!regex.IsMatch(textBox1.Text))
    {
        MessageBox.Show("Please enter only numbers.");
        textBox1.Text = string.Empty; // Clear invalid input
    }
}

Here, the regular expression ^\d+$ ensures that the textbox contains only numeric values. Any non-numeric input triggers a warning and resets the textbox.

Using MaskedTextBox for Predefined Input Patterns

The MaskedTextBox control is ideal for restricting input to numeric formats. It allows you to define input masks, ensuring users can only enter valid values.

Example Code

📄

maskedTextBox1.Mask = "00000"; // Accepts up to 5 digits

This approach is simple and requires no additional event handling or validation logic.

Handling Numeric Input with WPF

In WPF, you can use the PreviewTextInput event for similar functionality.

Example Code

📄

private void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    e.Handled = !int.TryParse(e.Text, out _);
}

Here, int.TryParse determines if the entered text is numeric, and invalid input is prevented using e.Handled = true.

Comparison of Methods

FAQs

How can I ensure only numbers are entered in a C# textbox?

You can use the KeyPress event, regular expressions, or controls like MaskedTextBox to restrict input to numeric values.

What is the difference between KeyPress and TextChanged events?

The KeyPress event validates input as it is typed, while the TextChanged event occurs after the input is modified, making it more suited for post-validation.

Can I allow decimal numbers in the textbox?

Yes, you can modify the validation logic to include a decimal point. For example, update the Regex pattern to ^\d+(\.\d+)?$ for decimal validation.

Is it better to use MaskedTextBox for numeric input?

Yes, if the input has a predefined format (e.g., ZIP codes or phone numbers), MaskedTextBox is simpler and more efficient.

Can I validate numeric input in WPF?

Yes, WPF applications can use the PreviewTextInput event or data binding with validation rules to restrict numeric input.

Conclusion

Creating a C# textbox that only accepts numbers is straightforward with the right approach. Whether you use event handling, regex numeric validation, or specialized controls like MaskedTextBox, each method has its unique advantages. Choose the approach that best fits your application’s requirements to ensure a seamless and error-free user experience.