How do I make a textbox that only accepts numbers?

And just because it's always more fun to do stuff in one line...

 private void textBox1_KeyPress(object sender, KeyPressEventArgs e) { e.Handled = !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar); } 

NOTE: This DOES NOT prevent a user from Copy / Paste into this textbox. It's not a fail safe way to sanitize your data.

I am assuming from context and the tags you used that you are writing a .NET C# app. In this case, you can subscribe to the text changed event, and validate each key stroke.

private void textBox1_TextChanged(object sender, EventArgs e) { if (System.Text.RegularExpressions.Regex.IsMatch(textBox1.Text, "[^0-9]")) { MessageBox.Show("Please enter only numbers."); textBox1.Text = textBox1.Text.Remove(textBox1.Text.Length - 1); } } 

Here is a simple standalone Winforms custom control, derived from the standard TextBox, that allows only System.Int32 input (it could be easily adapted for other types such as System.Int64, etc.). It supports copy/paste operations and negative numbers:

public class Int32TextBox : TextBox { protected override void OnKeyPress(KeyPressEventArgs e) { base.OnKeyPress(e); NumberFormatInfo fi = CultureInfo.CurrentCulture.NumberFormat; string c = e.KeyChar.ToString(); if (char.IsDigit(c, 0)) return; if ((SelectionStart == 0) && (c.Equals(fi.NegativeSign))) return; // copy/paste if ((((int)e.KeyChar == 22) || ((int)e.KeyChar == 3)) && ((ModifierKeys & Keys.Control) == Keys.Control)) return; if (e.KeyChar == '\b') return; e.Handled = true; } protected override void WndProc(ref System.Windows.Forms.Message m) { const int WM_PASTE = 0x0302; if (m.Msg == WM_PASTE) { string text = Clipboard.GetText(); if (string.IsNullOrEmpty(text)) return; if ((text.IndexOf('+') >= 0) && (SelectionStart != 0)) return; int i; if (!int.TryParse(text, out i)) // change this for other integer types return; if ((i < 0) && (SelectionStart != 0)) return; } base.WndProc(ref m); } 

Update 2017: My first answer has some issues:

• you can type something that's longer than an integer of a given type (for example 2147483648 is greater than Int32.MaxValue);
• more generally, there's no real validation of the result of what has been typed;
• it only handles int32, you'll have to write specific TextBox derivated control for each type (Int64, etc.)

So I came up with another version that's more generic, that still supports copy/paste, + and - sign, etc.

public class ValidatingTextBox : TextBox { private string _validText; private int _selectionStart; private int _selectionEnd; private bool _dontProcessMessages; public event EventHandler<TextValidatingEventArgs> TextValidating; protected virtual void OnTextValidating(object sender, TextValidatingEventArgs e) => TextValidating?.Invoke(sender, e); protected override void WndProc(ref Message m) { base.WndProc(ref m); if (_dontProcessMessages) return; const int WM_KEYDOWN = 0x100; const int WM_ENTERIDLE = 0x121; const int VK_DELETE = 0x2e; bool delete = m.Msg == WM_KEYDOWN && (int)m.WParam == VK_DELETE; if ((m.Msg == WM_KEYDOWN && !delete) || m.Msg == WM_ENTERIDLE) { DontProcessMessage(() => { _validText = Text; _selectionStart = SelectionStart; _selectionEnd = SelectionLength; }); } const int WM_CHAR = 0x102; const int WM_PASTE = 0x302; if (m.Msg == WM_CHAR || m.Msg == WM_PASTE || delete) { string newText = null; DontProcessMessage(() => { newText = Text; }); var e = new TextValidatingEventArgs(newText); OnTextValidating(this, e); if (e.Cancel) { DontProcessMessage(() => { Text = _validText; SelectionStart = _selectionStart; SelectionLength = _selectionEnd; }); } } } private void DontProcessMessage(Action action) { _dontProcessMessages = true; try { action(); } finally { _dontProcessMessages = false; } } } public class TextValidatingEventArgs : CancelEventArgs { public TextValidatingEventArgs(string newText) => NewText = newText; public string NewText { get; } } 

For Int32, you can either derive from it, like this:

public class Int32TextBox : ValidatingTextBox { protected override void OnTextValidating(object sender, TextValidatingEventArgs e) { e.Cancel = !int.TryParse(e.NewText, out int i); } } 

or w/o derivation, use the new TextValidating event like this:

var vtb = new ValidatingTextBox(); ... vtb.TextValidating += (sender, e) => e.Cancel = !int.TryParse(e.NewText, out int i); 

but what's nice is it works with any string, and any validation routine.

This is exactly what the Validated/Validating events were designed for.

Here's the MSDN article on the topic: Control.Validating Event.

The TL;DR version: Check the .Text property in the Validating event and set e.Cancel=True when the data is invalid.

When you set e.Cancel = True, the user can't leave the field, but you will need to give them some kind of feedback that something's wrong. I change the box's background color to light red to indicate a problem. Make sure to set it back to SystemColors.Window when Validating is called with a good value.

Try a MaskedTextBox. It takes a simple mask format so you can limit the input to numbers or dates or whatever.

You can use the TextChanged event

private void textBox_BiggerThan_TextChanged(object sender, EventArgs e) { long a; if (! long.TryParse(textBox_BiggerThan.Text, out a)) { // If not int clear textbox text or Undo() last operation textBox_LessThan.Clear(); } } 

Just use a NumericUpDown control and set those ugly up down buttons visibility to false.

numericUpDown1.Controls[0].Visible = false; 

NumericUpDown is actually a collection of controls containing a 'spin box' (up down buttons), a text box and some code to validate and wange-jangle it all together.

Marking:

YourNumericUpDown.Controls[0].visible = false 

will hide the buttons while keeping the underlying code active.

While not being an obvious solution it is simple and effective. .Controls[1] would hide the text box portion if you wanted to do that instead.

This might be useful. It allows "real" numeric values, including proper decimal points and preceding plus or minus signs. Call it from within the related KeyPress event.

 private bool IsOKForDecimalTextBox(char theCharacter, TextBox theTextBox) { // Only allow control characters, digits, plus and minus signs. // Only allow ONE plus sign. // Only allow ONE minus sign. // Only allow the plus or minus sign as the FIRST character. // Only allow ONE decimal point. // Do NOT allow decimal point or digits BEFORE any plus or minus sign. if ( !char.IsControl(theCharacter) && !char.IsDigit(theCharacter) && (theCharacter != '.') && (theCharacter != '-') && (theCharacter != '+') ) { // Then it is NOT a character we want allowed in the text box. return false; } // Only allow one decimal point. if (theCharacter == '.' && theTextBox.Text.IndexOf('.') > -1) { // Then there is already a decimal point in the text box. return false; } // Only allow one minus sign. if (theCharacter == '-' && theTextBox.Text.IndexOf('-') > -1) { // Then there is already a minus sign in the text box. return false; } // Only allow one plus sign. if (theCharacter == '+' && theTextBox.Text.IndexOf('+') > -1) { // Then there is already a plus sign in the text box. return false; } // Only allow one plus sign OR minus sign, but not both. if ( ( (theCharacter == '-') || (theCharacter == '+') ) && ( (theTextBox.Text.IndexOf('-') > -1) || (theTextBox.Text.IndexOf('+') > -1) ) ) { // Then the user is trying to enter a plus or minus sign and // there is ALREADY a plus or minus sign in the text box. return false; } // Only allow a minus or plus sign at the first character position. if ( ( (theCharacter == '-') || (theCharacter == '+') ) && theTextBox.SelectionStart != 0 ) { // Then the user is trying to enter a minus or plus sign at some position // OTHER than the first character position in the text box. return false; } // Only allow digits and decimal point AFTER any existing plus or minus sign if ( ( // Is digit or decimal point char.IsDigit(theCharacter) || (theCharacter == '.') ) && ( // A plus or minus sign EXISTS (theTextBox.Text.IndexOf('-') > -1) || (theTextBox.Text.IndexOf('+') > -1) ) && // Attempting to put the character at the beginning of the field. theTextBox.SelectionStart == 0 ) { // Then the user is trying to enter a digit or decimal point in front of a minus or plus sign. return false; } // Otherwise the character is perfectly fine for a decimal value and the character // may indeed be placed at the current insertion position. return true; } 

I've been working on a collection of components to complete missing stuff in WinForms, here it is: Advanced Forms

In particular this is the class for a Regex TextBox

/// <summary>Represents a Windows text box control that only allows input that matches a regular expression.</summary> public class RegexTextBox : TextBox { [NonSerialized] string lastText; /// <summary>A regular expression governing the input allowed in this text field.</summary> [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] public virtual Regex Regex { get; set; } /// <summary>A regular expression governing the input allowed in this text field.</summary> [DefaultValue(null)] [Category("Behavior")] [Description("Sets the regular expression governing the input allowed for this control.")] public virtual string RegexString { get { return Regex == null ? string.Empty : Regex.ToString(); } set { if (string.IsNullOrEmpty(value)) Regex = null; else Regex = new Regex(value); } } protected override void OnTextChanged(EventArgs e) { if (Regex != null && !Regex.IsMatch(Text)) { int pos = SelectionStart - Text.Length + (lastText ?? string.Empty).Length; Text = lastText; SelectionStart = Math.Max(0, pos); } lastText = Text; base.OnTextChanged(e); } } 

Simply adding something like myNumbericTextBox.RegexString = "^(\\d+|)$"; should suffice.

Both integers and floats need to be accepted, including the negative numbers.

private void textBox1_KeyPress(object sender, KeyPressEventArgs e) { // Text string text = ((Control) sender).Text; // Is Negative Number? if (e.KeyChar == '-' && text.Length == 0) { e.Handled = false; return; } // Is Float Number? if (e.KeyChar == '.' && text.Length > 0 && !text.Contains(".")) { e.Handled = false; return; } // Is Digit? e.Handled = (!char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar)); } 

Simply use this code in the TextBox:

private void textBox1_TextChanged(object sender, EventArgs e) { double parsedValue; if (!double.TryParse(textBox1.Text, out parsedValue)) { textBox1.Text = ""; } } 

I have made something for this on CodePlex.

It works by intercepting the TextChanged event. If the result is a good number it will be stored. If it is something wrong, the last good value will be restored. The source is a bit too large to publish here, but here is a link to the class that handles the core of this logic.

In our webpage with the definition of textbox we can add an onkeypress event for accepting only numbers. It will not show any message but it will prevent you from wrong input. It worked for me, user could not enter anything except number.

<asp:TextBox runat="server" ID="txtFrom" onkeypress="if(isNaN(String.fromCharCode(event.keyCode))) return false;"> 

This is my aproach:

1. using linq (easy to modify filter)
2. copy/paste proof code
3. keeps caret position when you press a forbidden character
4. accepts left zeroes

5. and any size numbers

   private void numeroCuenta_TextChanged(object sender, EventArgs e) { string org = numeroCuenta.Text; string formated = string.Concat(org.Where(c => (c >= '0' && c <= '9'))); if (formated != org) { int s = numeroCuenta.SelectionStart; if (s > 0 && formated.Length > s && org[s - 1] != formated[s - 1]) s--; numeroCuenta.Text = formated; numeroCuenta.SelectionStart = s; } } 

This is a nice and short way to do it with .NET 5/Core

private void textBox1_KeyDown(object sender, KeyEventArgs e) { if (e.KeyData != Keys.Back) e.SuppressKeyPress = !int.TryParse(Convert.ToString((char) e.KeyData), out int _); } 

Edit: Added support for backspace key

you could use TextChanged/ Keypress event, use a regex to filter on numbers and take some action.

private void txt3_KeyPress(object sender, KeyPressEventArgs e) { for (int h = 58; h <= 127; h++) { if (e.KeyChar == h) //58 to 127 is alphabets tat will be blocked { e.Handled = true; } } for(int k=32;k<=47;k++) { if (e.KeyChar == k) //32 to 47 are special characters tat will { be blocked e.Handled = true; } } } 

try this is very simple

Take a look at Input handling in WinForm

I have posted my solution which uses the ProcessCmdKey and OnKeyPress events on the textbox. The comments show you how to use a Regex to verify the keypress and block/allow appropriately.

Hi you can do something like this in the textchanged event of the textbox.

here is a demo

 private void textBox1_TextChanged(object sender, EventArgs e) { string actualdata = string.Empty; char[] entereddata = textBox1.Text.ToCharArray(); foreach (char aChar in entereddata.AsEnumerable()) { if (Char.IsDigit(aChar)) { actualdata = actualdata + aChar; // MessageBox.Show(aChar.ToString()); } else { MessageBox.Show(aChar + " is not numeric"); actualdata.Replace(aChar, ' '); actualdata.Trim(); } } textBox1.Text = actualdata; } 

It seems like many of the current answers to this question are manually parsing the input text. If you're looking for a specific built-in numeric type (e.g. int or double), why not just delegate the work to that type's TryParse method? For example:

public class IntTextBox : TextBox { string PreviousText = ""; int BackingResult; public IntTextBox() { TextChanged += IntTextBox_TextChanged; } public bool HasResult { get; private set; } public int Result { get { return HasResult ? BackingResult : default(int); } } void IntTextBox_TextChanged(object sender, EventArgs e) { HasResult = int.TryParse(Text, out BackingResult); if (HasResult || string.IsNullOrEmpty(Text)) { // Commit PreviousText = Text; } else { // Revert var changeOffset = Text.Length - PreviousText.Length; var previousSelectionStart = Math.Max(0, SelectionStart - changeOffset); Text = PreviousText; SelectionStart = previousSelectionStart; } } } 

If you want something more generic but still compatible with Visual Studio's Designer:

public class ParsableTextBox : TextBox { TryParser BackingTryParse; string PreviousText = ""; object BackingResult; public ParsableTextBox() : this(null) { } public ParsableTextBox(TryParser tryParse) { TryParse = tryParse; TextChanged += ParsableTextBox_TextChanged; } public delegate bool TryParser(string text, out object result); public TryParser TryParse { set { Enabled = !(ReadOnly = value == null); BackingTryParse = value; } } public bool HasResult { get; private set; } public object Result { get { return GetResult<object>(); } } public T GetResult<T>() { return HasResult ? (T)BackingResult : default(T); } void ParsableTextBox_TextChanged(object sender, EventArgs e) { if (BackingTryParse != null) { HasResult = BackingTryParse(Text, out BackingResult); } if (HasResult || string.IsNullOrEmpty(Text)) { // Commit PreviousText = Text; } else { // Revert var changeOffset = Text.Length - PreviousText.Length; var previousSelectionStart = Math.Max(0, SelectionStart - changeOffset); Text = PreviousText; SelectionStart = previousSelectionStart; } } } 

And finally, if you want something fully generic and don't care about Designer support:

public class ParsableTextBox<T> : TextBox { TryParser BackingTryParse; string PreviousText; T BackingResult; public ParsableTextBox() : this(null) { } public ParsableTextBox(TryParser tryParse) { TryParse = tryParse; TextChanged += ParsableTextBox_TextChanged; } public delegate bool TryParser(string text, out T result); public TryParser TryParse { set { Enabled = !(ReadOnly = value == null); BackingTryParse = value; } } public bool HasResult { get; private set; } public T Result { get { return HasResult ? BackingResult : default(T); } } void ParsableTextBox_TextChanged(object sender, EventArgs e) { if (BackingTryParse != null) { HasResult = BackingTryParse(Text, out BackingResult); } if (HasResult || string.IsNullOrEmpty(Text)) { // Commit PreviousText = Text; } else { // Revert var changeOffset = Text.Length - PreviousText.Length; var previousSelectionStart = Math.Max(0, SelectionStart - changeOffset); Text = PreviousText; SelectionStart = previousSelectionStart; } } } 

Using the approach described in Fabio Iotti's answer I have created a more generic solution:

public abstract class ValidatedTextBox : TextBox { private string m_lastText = string.Empty; protected abstract bool IsValid(string text); protected sealed override void OnTextChanged(EventArgs e) { if (!IsValid(Text)) { var pos = SelectionStart - Text.Length + m_lastText.Length; Text = m_lastText; SelectionStart = Math.Max(0, pos); } m_lastText = Text; base.OnTextChanged(e); } } 

"ValidatedTextBox", which contains all nontrivial validation behavior. All that's left to do is inherit from this class and override "IsValid" method with whatever validation logic is required. For example, using this class, it is possible to create "RegexedTextBox" which will accept only strings which match specific regular expression:

public abstract class RegexedTextBox : ValidatedTextBox { private readonly Regex m_regex; protected RegexedTextBox(string regExpString) { m_regex = new Regex(regExpString); } protected override bool IsValid(string text) { return m_regex.IsMatch(Text); } } 

After that, inheriting from the "RegexedTextBox" class, we can easily create "PositiveNumberTextBox" and "PositiveFloatingPointNumberTextBox" controls:

public sealed class PositiveNumberTextBox : RegexedTextBox { public PositiveNumberTextBox() : base(@"^\d*$") { } } public sealed class PositiveFloatingPointNumberTextBox : RegexedTextBox { public PositiveFloatingPointNumberTextBox() : base(@"^(\d+\" + CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator + @")?\d*$") { } } 

Here are more than 30 answers and a lot of answers are helpful. But I want to share a generalized form for the System.Windows.Forms.TextBox and System.Windows.Controls.TextBox.

There is not available KeyPress event in System.Windows.Controls.TextBox. This answer is for those people who want to implement with the same logic for System.Windows.Forms.TextBox and System.Windows.Controls.TextBox.

This is NumberTextBox code. Use commented line instead of the previous line for System.Windows.Controls.TextBox.

public class NumberTextBox : System.Windows.Forms.TextBox //public class NumberTextBox : System.Windows.Controls.TextBox { private double _maxValue; private double _minValue; private bool _flag; private string _previousValue; public NumberTextBox() { this.TextAlign = HorizontalAlignment.Right; //TextAlignment = TextAlignment.Right; KeyDown += TextBox_KeyDown; TextChanged += TextBox_TextChanged; _minValue = double.MinValue; _maxValue = double.MaxValue; } private void TextBox_KeyDown(object sender, KeyEventArgs e) { _previousValue = this.Text; _flag = this.SelectedText.Length > 0; } private void TextBox_TextChanged(object sender, EventArgs e) //private void TextBox_TextChanged(object sender, TextChangedEventArgs e) { var text = this.Text; if (text.Length < 1) return; var cursorPosition = SelectionStart == 0 ? SelectionStart : SelectionStart - 1; var insertedChar = text[cursorPosition]; if (IsInvalidInput(insertedChar, cursorPosition, text)) { HandleText(text, cursorPosition); } ValidateRange(text, cursorPosition); } private bool IsInvalidInput(char insertedChar, int cursorPosition, string text) { return !char.IsDigit(insertedChar) && insertedChar != '.' && insertedChar != '-' || insertedChar == '-' && cursorPosition != 0 || text.Count(x => x == '.') > 1 || text.Count(x => x == '-') > 1; } private void HandleText(string text, int cursorPosition) { this.Text = _flag ? _previousValue : text.Remove(cursorPosition, 1); this.SelectionStart = cursorPosition; this.SelectionLength = 0; } private void ValidateRange(string text, int cursorPosition) { try { if (text == "." || _minValue < 0 && text == "-") return; var doubleValue = Convert.ToDouble(text); if (doubleValue > _maxValue || doubleValue < _minValue) { HandleText(text, cursorPosition); } } catch (Exception) { HandleText(text, cursorPosition); } } protected void SetProperties(double minValue = double.MinValue, double maxValue = double.MaxValue) { _minValue = minValue; _maxValue = maxValue; } } 

PositiveNumberTextBox code:

public class PositiveNumberTextBox : NumberTextBox { public PositiveNumberTextBox() { SetProperties(0); } } 

FractionNumberTextBox code:

public class FractionNumberTextBox : NumberTextBox { public FractionNumberTextBox() { SetProperties(0, 0.999999); } } 

I would handle it in the KeyDown event.

void TextBox_KeyDown(object sender, KeyEventArgs e) { char c = Convert.ToChar(e.PlatformKeyCode); if (!char.IsDigit(c)) { e.Handled = true; } } 

Sorry to wake the dead, but I thought someone might find this useful for future reference.

Here is how I handle it. It handles floating point numbers, but can easily be modified for integers.

Basically you can only press 0 - 9 and .

You can only have one 0 before the .

All other characters are ignored and the cursor position maintained.

 private bool _myTextBoxChanging = false; private void myTextBox_TextChanged(object sender, EventArgs e) { validateText(myTextBox); } private void validateText(TextBox box) { // stop multiple changes; if (_myTextBoxChanging) return; _myTextBoxChanging = true; string text = box.Text; if (text == "") return; string validText = ""; bool hasPeriod = false; int pos = box.SelectionStart; for (int i = 0; i < text.Length; i++ ) { bool badChar = false; char s = text[i]; if (s == '.') { if (hasPeriod) badChar = true; else hasPeriod = true; } else if (s < '0' || s > '9') badChar = true; if (!badChar) validText += s; else { if (i <= pos) pos--; } } // trim starting 00s while (validText.Length >= 2 && validText[0] == '0') { if (validText[1] != '.') { validText = validText.Substring(1); if (pos < 2) pos--; } else break; } if (pos > validText.Length) pos = validText.Length; box.Text = validText; box.SelectionStart = pos; _myTextBoxChanging = false; } 

Here is a quickly modified int version:

 private void validateText(TextBox box) { // stop multiple changes; if (_myTextBoxChanging) return; _myTextBoxChanging = true; string text = box.Text; if (text == "") return; string validText = ""; int pos = box.SelectionStart; for (int i = 0; i < text.Length; i++ ) { char s = text[i]; if (s < '0' || s > '9') { if (i <= pos) pos--; } else validText += s; } // trim starting 00s while (validText.Length >= 2 && validText.StartsWith("00")) { validText = validText.Substring(1); if (pos < 2) pos--; } if (pos > validText.Length) pos = validText.Length; box.Text = validText; box.SelectionStart = pos; _myTextBoxChanging = false; } 

This one works with copy and paste, drag and drop, key down, prevents overflow and is pretty simple

public partial class IntegerBox : TextBox { public IntegerBox() { InitializeComponent(); this.Text = 0.ToString(); } protected override void OnPaint(PaintEventArgs pe) { base.OnPaint(pe); } private String originalValue = 0.ToString(); private void Integerbox_KeyPress(object sender, KeyPressEventArgs e) { originalValue = this.Text; } private void Integerbox_TextChanged(object sender, EventArgs e) { try { if(String.IsNullOrWhiteSpace(this.Text)) { this.Text = 0.ToString(); } this.Text = Convert.ToInt64(this.Text.Trim()).ToString(); } catch (System.OverflowException) { MessageBox.Show("Value entered is to large max value: " + Int64.MaxValue.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); this.Text = originalValue; } catch (System.FormatException) { this.Text = originalValue; } catch (System.Exception ex) { this.Text = originalValue; MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK , MessageBoxIcon.Error); } } } 

Do not forget that a user can paste an invalid text in a TextBox.

If you want to restrict that, follow the below code:

private void ultraTextEditor1_TextChanged(object sender, EventArgs e) { string append=""; foreach (char c in ultraTextEditor1.Text) { if ((!Char.IsNumber(c)) && (c != Convert.ToChar(Keys.Back))) { } else { append += c; } } ultraTextEditor1.Text = append; } 

I was also looking for the best way to check only numbers in textbox and problem with keypress was it does not support copy paste by right click or clipboard so came up with this code which validates the when cursor leaves the text field and also it checks for empty field. (adapted version of newguy)

private void txtFirstValue_MouseLeave(object sender, EventArgs e) { int num; bool isNum = int.TryParse(txtFirstValue.Text.Trim(), out num); if (!isNum && txtFirstValue.Text != String.Empty) { MessageBox.Show("The First Value You Entered Is Not a Number, Please Try Again", "Invalid Value Detected", MessageBoxButtons.OK, MessageBoxIcon.Error); txtFirstValue.Clear(); } } 

one line code decimal point allowed

 private void txtQty_KeyPress(object sender, KeyPressEventArgs e) { e.Handled = e.KeyChar != '.' && !char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar); } 

int Number; bool isNumber; isNumber = int32.TryPase(textbox1.text, out Number); if (!isNumber) { (code if not an integer); } else { (code if an integer); }