Comment puis-je faire une zone de texte qui accepte uniquement les numéros?

Et juste parce que c'est toujours plus de plaisir à faire des choses en une seule ligne...

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

REMARQUE: Cela N'empêche PAS un utilisateur de Copier /Coller dans cette zone de texte. Ce n'est pas un fail safe façon de désinfecter vos données.

Ici est une simple autonome Winforms de contrôle personnalisé, dérivé de la zone de texte standard, qui permet à seul Système.Int32 entrée (il peut être facilement adapté à d'autres types tels que Système.Int64, etc.). Il prend en charge les opérations copier/coller et les nombres négatifs:

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

Mise à jour en 2017: Ma première réponse a certaines questions:

• vous pouvez taper quelque chose qui est plus que d'un nombre entier d'un type donné (par exemple 2147483648 est plus grand que Int32.MaxValue);
• plus généralement, il n'y a pas de véritable validation de la résultat de ce qui a été tapé;
• il ne gère int32, vous aurez à écrire des TextBox dérivés de contrôle pour chaque type (Int64, etc.)

Alors je suis venu avec une autre version plus générique, qui soutient encore le copier/coller, + et - signe, 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; }
}

Pour Int32, vous pouvez en tirer, comme ceci:

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

ou w/o dérivation, utilisez la nouvelle TextValidating événement comme celui-ci:

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

mais ce qui est bien c'est qu'il fonctionne avec n'importe quelle chaîne, et de toute routine de validation.

Essayer un MaskedTextBox. Il prend un simple masque de format de sorte que vous pouvez limiter la saisie de nombres ou de dates ou de quoi que ce soit.

Ça peut être utile. Il permet de "vraies" valeurs numériques, y compris le point décimal et le précédent signes plus ou moins. Appel à partir de l'intérieur de la relative événement KeyPress.

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

J'ai fait quelque chose pour cela sur CodePlex.

Il fonctionne en interceptant l'événement TextChanged. Si le résultat est un bon nombre, il sera stocké. Si c'est quelque chose de mal, la dernière bonne valeur sera restauré. La source est un peu trop grand pour publier ici, mais voici un lien vers la catégorie qui gère la base de cette logique.

Dans notre site web, avec la définition de la zone de texte, on peut ajouter une onkeypress événement pour accepter uniquement des chiffres. Il n'affiche aucun message, mais il va vous empêcher de saisie erronée. Il a travaillé pour moi, l'utilisateur ne pourrait pas entrer quoi que ce soit sauf le nombre.

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

vous pouvez utiliser TextChanged/événement Keypress, utiliser une regex pour filtrer sur les chiffres et prendre des mesures.

Prendre un coup d'oeil à De gérer les entrées en WinForm

J'ai posté ma solution qui utilise le ProcessCmdKey et OnKeyPress événements sur la zone de texte. Les commentaires vous montrer comment utiliser une Regex pour vérifier la pression de touche et de bloquer/autoriser de manière appropriée.

Il semble que de nombreuses réponses à cette question sont manuellement l'analyse du texte d'entrée. Si vous êtes à la recherche pour un intégré de type numérique (par exemple, int ou double), pourquoi ne pas déléguer le travail à ce type de TryParse méthode? Par exemple:

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

Si vous voulez quelque chose de plus générique, mais toujours compatible avec Visual Studio 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;
}
}
}

Et enfin, si vous voulez quelque chose de complètement générique et ne se soucient pas de la prise en charge du Concepteur:

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

En utilisant l'approche décrite dans Fabio Iotti réponse j'ai créé un plus solution générique:

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", qui contient tous les non trivial de validation de comportement.
Tout ce qui reste à faire est d'hériter de cette classe et de remplacer "IsValid" avec quelle que soit la logique de validation est nécessaire.
Par exemple, l'utilisation de cette classe, il est possible de créer des "RegexedTextBox" qui accepte uniquement les chaînes en fonction de l'expression régulière:

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

Après cela, l'héritage du "RegexedTextBox" de classe, nous pouvons facilement créer des "PositiveNumberTextBox" et "PositiveFloatingPointNumberTextBox" contrôles:

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

Je voudrais y faire face dans l'événement KeyDown.

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

Ne pas oublier qu'un utilisateur peut coller une défaillance de texte dans un TextBox.

Si vous souhaitez restreindre l', suivez le code ci-dessous:

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

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

Bouton de clic, vous pouvez vérifier le texte de la textbox par boucle for:

char[] c = txtGetCustomerId.Text.ToCharArray();
bool IsDigi = true;
for (int i = 0; i < c.Length; i++)
{
if (c[i] < '0' || c[i] > '9')
{ IsDigi = false; }
}
if (IsDigi)
{ 
//do something
}

FAIL-SAFE et simple "récursive" la méthode, qui peut être utilisé avec plusieurs zones de texte.

Il bloque le mauvais clavier les caractères tapés et aussi collé valeurs, etc. Il n'accepte que des nombres entiers, et le nombre maximum de longueur est la longueur maximale d'une chaîne de type (qui est de type int, très longue!)

public void Check_If_Int_On_TextChanged(object sender, EventArgs e)
{
//This method checks that each inputed character is a number. Any non-numeric
//characters are removed from the text
TextBox textbox = (TextBox)sender;
//If the text is empty, return
if (textbox.Text.Length == 0) { return; }
//Check the new Text value if it's only numbers
byte parsedValue;
if (!byte.TryParse(textbox.Text[(textbox.Text.Length - 1)].ToString(), out parsedValue))
{
//Remove the last character as it wasn't a number
textbox.Text = textbox.Text.Remove((textbox.Text.Length - 1));
//Move the cursor to the end of text
textbox.SelectionStart = textbox.Text.Length;
}
}

Here is a simple solution that works for me.
public static bool numResult;
public static bool checkTextisNumber(string numberVal)
{
try
{
if (numberVal.Equals("."))
{
numResult = true;
}
else if (numberVal.Equals(""))
{
numResult = true;
}
else
{
decimal number3 = 0;
bool canConvert = decimal.TryParse(numberVal, out number3);
if (canConvert == true)
{
numResult = true;
}
else
numResult = false;
}
}
catch (System.Exception ex)
{
numResult = false;
}
return numResult;
}
string correctNum;
private void tBox_NumTester_TextChanged(object sender, TextChangedEventArgs e)
{
if(checkTextisNumber(tBox_NumTester.Text))
{
correctNum = tBox_NumTester.Text;
}
else
{
tBox_NumTester.Text = correctNum;
}
}

C'est mon approche:

1. à l'aide de linq (facile à modifier le filtre)
2. copier/coller preuve code
3. garde la position du curseur lorsque vous appuyez sur un interdit caractère
4. accepte gauche zéros

5. et de toute taille numéros de

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