web-dev-qa-db-de.com

Wie erstelle ich ein Textfeld, das nur Zahlen akzeptiert?

Ich habe eine Windows Forms-App mit einem Textfeldsteuerelement, das ich nur Integer-Werte akzeptieren möchte. In der Vergangenheit habe ich diese Art der Validierung durchgeführt, indem ich das KeyPress-Ereignis überlade und nur Zeichen entferne, die nicht der Spezifikation entsprachen. Ich habe mir das MaskedTextBox-Steuerelement angesehen, möchte aber eine allgemeinere Lösung, die vielleicht mit einem regulären Ausdruck funktioniert oder von den Werten anderer Steuerelemente abhängt.

Idealerweise würde sich dies so verhalten, dass das Drücken eines nicht numerischen Zeichens entweder kein Ergebnis liefert oder dem Benutzer sofort eine Rückmeldung über das ungültige Zeichen gibt.

523
Mykroft

Zwei Optionen:

  1. Verwenden Sie stattdessen eine NumericUpDown . NumericUpDown übernimmt die Filterung für Sie. Dies ist Nizza. Natürlich haben Sie auch die Möglichkeit, die Aufwärts- und Abwärtspfeile auf der Tastatur zu drücken, um den aktuellen Wert zu erhöhen und zu verringern.

  2. Behandeln Sie die entsprechenden Tastaturereignisse, um alles andere als numerische Eingabe zu verhindern. Ich hatte Erfolg mit diesen zwei Ereignishandlern in einer Standard-TextBox:

    private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
    {
        if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar) &&
            (e.KeyChar != '.'))
        {
                e.Handled = true;
        }
    
        // only allow one decimal point
        if ((e.KeyChar == '.') && ((sender as TextBox).Text.IndexOf('.') > -1))
        {
            e.Handled = true;
        }
    }
    

Sie können die Prüfung auf '.' (und die anschließende Überprüfung auf mehr als einen '.') entfernen, wenn Ihre TextBox keine Dezimalstellen zulässt. Sie können auch eine Überprüfung für '-' hinzufügen, wenn Ihr TextBox negative Werte zulassen soll.

Wenn Sie den Benutzer auf die Anzahl der Ziffern beschränken möchten, verwenden Sie: textBox1.MaxLength = 2; // this will allow the user to enter only 2 digits

720
Matt Hamilton

Und nur weil es immer mehr Spaß macht, Sachen in einer Zeile zu erledigen ...

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

HINWEIS: Dies verhindert NICHT, dass ein Benutzer in dieses Textfeld kopieren/einfügen kann. Es ist keine sichere Methode, um Ihre Daten zu säubern.

123
BFree

Ich gehe aus dem Kontext und den von Ihnen verwendeten Tags davon aus, dass Sie eine .NET C # -App schreiben. In diesem Fall können Sie das Ereignis "Text geändert" abonnieren und jeden Tastenanschlag überprüfen.

    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);
        }
    }
46
Anthony D

Hier ist ein einfaches, eigenständiges, benutzerdefiniertes Winforms-Steuerelement, abgeleitet von der Standard-TextBox, das nur die Eingabe von System.Int32 zulässt (es kann leicht für andere Typen wie System.Int64 usw. angepasst werden). Es unterstützt Kopieren/Einfügen und negative Zahlen:

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 : Meine erste Antwort hat einige Probleme:

  • sie können etwas eingeben, das länger ist als eine ganze Zahl eines bestimmten Typs (zum Beispiel 2147483648 ist größer als Int32.MaxValue);
  • im Allgemeinen gibt es keine wirkliche Bestätigung des Ergebnis dessen, was eingegeben wurde.
  • es behandelt nur int32, Sie müssen für jeden Typ ein bestimmtes von TextBox abgeleitetes Steuerelement schreiben (Int64 usw.).

Also habe ich mir eine andere, generischere Version ausgedacht, die noch Copy/Paste, + und - Zeichen usw. unterstützt.

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

Für Int32 können Sie entweder davon ableiten:

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

oder ohne Ableitung verwenden Sie das neue TextValidating-Ereignis wie folgt:

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

aber was ist schön ist, funktioniert es mit jeder Zeichenfolge und Validierungsroutine.

31
Simon Mourier

Genau dafür wurden die Validated/Validating-Ereignisse konzipiert.

Hier ist der MSDN-Artikel zum Thema: http://msdn.Microsoft.com/en-us/library/system.windows.forms.control.validating.aspx

Die TL; DR-Version: Überprüfen Sie die .Text-Eigenschaft im Validating-Ereignis, und legen Sie e.Cancel=True fest, wenn die Daten ungültig sind.

Wenn Sie e.Cancel = True festlegen, kann der Benutzer das Feld nicht verlassen. Sie müssen ihm jedoch eine Rückmeldung geben, dass etwas nicht stimmt. Ich ändere die Hintergrundfarbe der Box in hellrot, um ein Problem anzuzeigen. Stellen Sie sicher, dass es wieder auf SystemColors.Window gesetzt ist, wenn Validating mit einem guten Wert aufgerufen wird.

17
TomXP411

Versuchen Sie eine MaskedTextBox . Es ist ein einfaches Maskenformat erforderlich, damit Sie die Eingabe auf Zahlen, Datumsangaben oder anderes beschränken können.

12
Andrew Kennan

Sie können das Ereignis TextChanged verwenden

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();
    }
}
11
Davit Tvildiani

Das könnte nützlich sein. Es erlaubt "echte" numerische Werte, einschließlich der richtigen Dezimalpunkte und vorangestellter Plus- oder Minuszeichen. Rufen Sie es aus dem zugehörigen KeyPress-Ereignis auf.

       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;
    }
5
Roger Garrett

Ich habe an einer Sammlung von Komponenten gearbeitet, um fehlende Elemente in WinForms zu vervollständigen. Hier ist es: Advanced Forms

Dies ist insbesondere die Klasse für eine 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);
    }
}

Das Hinzufügen von etwas wie myNumbericTextBox.RegexString = "^(\\d+|)$"; sollte ausreichen.

5
Fabio Iotti

Ich habe etwas auf CodePlex gemacht.

Es funktioniert durch Abfangen des TextChanged-Ereignisses. Wenn das Ergebnis eine gute Zahl ist, wird diese gespeichert. Wenn etwas nicht stimmt, wird der letzte gute Wert wiederhergestellt. Die Quelle ist etwas zu groß, um sie hier zu veröffentlichen, aber hier ist ein Link zur Klasse , die den Kern dieser Logik handhabt.

4
GvS

verwenden Sie einfach diesen Code in der Textbox:

private void textBox1_TextChanged(object sender, EventArgs e)
{

    double parsedValue;

    if (!double.TryParse(textBox1.Text, out parsedValue))
    {
        textBox1.Text = "";
    }
}
4
saurabh27

In unserer Webseite mit der Definition von Textfeld können wir ein onkeypress -Ereignis hinzufügen, um nur Zahlen zu akzeptieren. Es wird keine Nachricht angezeigt, aber es wird verhindert, dass Sie falsche Eingaben machen. Es funktionierte für mich, der Benutzer konnte außer der Nummer nichts eingeben.

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

Verwenden Sie einfach ein NumericUpDown-Steuerelement und setzen Sie die Sichtbarkeit dieser unschönen Tasten auf false.

numericUpDown1.Controls[0].Visible = false;

NumericUpDown ist eigentlich eine Sammlung von Steuerelementen, die ein 'Drehfeld' (Schaltflächen nach oben/unten), ein Textfeld und einen Code zum Überprüfen und Zusammenstellen enthalten. 

Markierung:

YourNumericUpDown.Controls[0].visible = false 

blendet die Schaltflächen aus, während der zugrunde liegende Code aktiv bleibt. 

Obwohl es keine offensichtliche Lösung ist, ist es einfach und effektiv. .Controls[1] würde den Textfeldbereich ausblenden, wenn Sie dies stattdessen tun wollten.

3
user2163234

Es scheint, als würden viele der aktuellen Antworten auf diese Frage den Eingabetext manuell analysieren. Wenn Sie nach einem bestimmten integrierten numerischen Typ suchen (beispielsweise int oder double), können Sie die Arbeit nicht einfach an die TryParse-Methode dieses Typs delegieren. Zum Beispiel:

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

Wenn Sie etwas mehr generisches wollen, aber dennoch mit dem Designer von Visual Studio kompatibel sind:

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

Und schließlich, wenn Sie etwas ganz generisches wollen und sich nicht für Designer-Unterstützung interessieren:

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

versuchen Sie, das ist sehr einfach

2
rithish

Sowohl Ganzzahlen als auch Floats müssen akzeptiert werden, einschließlich der negativen Zahlen.

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

Hallo, Sie können so etwas in dem textchanged -Ereignis der Textbox tun. 

hier ist eine 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;
    }
2
Chandan Kumar

sie könnten das TextChanged / Keypress -Ereignis verwenden, einen Regex zum Filtern von Zahlen verwenden und Maßnahmen ergreifen.

2
Perpetualcoder

Werfen Sie einen Blick auf Eingabeverarbeitung in WinForm

Ich habe meine Lösung mit den Ereignissen ProcessCmdKey und OnKeyPress in der Textbox bereitgestellt. Die Kommentare zeigen Ihnen, wie Sie mit einer Regex den Tastendruck überprüfen und entsprechend sperren/zulassen.

2
benPearce

Mit dem in Antwort von Fabio Iotti beschriebenen Ansatz habe ich eine generischere Lösung geschaffen:

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" enthält alles nicht-triviale Validierungsverhalten . Es bleibt nur noch das Erben dieser Klasse und das Überschreiben der "IsValid" -Methode mit der erforderlichen Validierungslogik . Beispielsweise ist diese Klasse möglich Erstellen Sie "RegexedTextBox", das nur Zeichenfolgen akzeptiert, die mit bestimmten regulären Ausdrücken übereinstimmen:

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

Nachdem wir von der Klasse "RegexedTextBox" geerbt haben, können Sie auf einfache Weise die Steuerelemente "PositiveNumberTextBox" und "PositiveFloatingPointNumberTextBox" erstellen:

public sealed class PositiveNumberTextBox : RegexedTextBox {
    public PositiveNumberTextBox() : base(@"^\d*$") { }
}

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

Tut mir leid, die Toten zu wecken, aber ich dachte, jemand könnte dies als Referenz für die Zukunft finden.

Hier verhalte ich mich damit. Es verarbeitet Fließkommazahlen, kann jedoch leicht für ganze Zahlen geändert werden.

Grundsätzlich können Sie nur 0 - 9 und drücken.

Sie können nur eine 0 vor der haben.

Alle anderen Zeichen werden ignoriert und die Cursorposition beibehalten.

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

Hier ist eine schnell modifizierte 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;
    }
1
yardape

Vergessen Sie nicht, dass ein Benutzer einen ungültigen Text in eine TextBox einfügen kann. 

Wenn Sie das einschränken möchten, folgen Sie dem folgenden 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;
}   
1
Divya

Ich war auch auf der Suche nach der besten Möglichkeit, nur Zahlen in Textfeldern zu überprüfen, und das Problem mit Tastendruck war, dass das Kopieren durch Rechtsklick oder die Zwischenablage nicht unterstützt wird. Daher kam dieser Code zum Einsatz, bei dem der Cursor überprüft wird, ob er das Textfeld verlässt und auch nach Text sucht leeres Feld. (angepasste Version von 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();
    }
}
1
Alston Antony

Ich würde es im KeyDown-Event behandeln. 

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

Dies funktioniert mit Kopieren und Einfügen, Ziehen und Ablegen, das Herunterfahren, verhindert Überlauf und ist ziemlich einfach

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

    }
0

Einfachere Antwort:

_textBox.TextChanged += delegate(System.Object o, System.EventArgs e)
{
    TextBox _tbox = o as TextBox;
    _tbox.Text = new string(_tbox.Text.Where(c => (char.IsDigit(c)) || (c == '.')).ToArray());
};
0
micahhoover

Das ist mein Ansatz:

  1. kopieren/Einfügen eines Korrekturcodes
  2. behält die Caret-Position, wenn Sie einen verbotenen Charakter drücken
  3. akzeptiert linke Nullen
  4. und beliebige Größen
  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;
        }
    }
    
0

ich mag knappen Code

    private void xmm_textbox_KeyPress(object sender, KeyPressEventArgs e) {
        double x;
        e.Handled = !double.TryParse(((TextBox)sender).Text, out x);
    }
0
reza
int Number;
bool isNumber;
isNumber = int32.TryPase(textbox1.text, out Number);

if (!isNumber)
{ 
    (code if not an integer);
}
else
{
    (code if an integer);
}
0
newguy

FAIL-SAFE und einfache "rekursive" Methode, die mit mehreren Textboxen verwendet werden kann.

Es blockiert die falsch eingegebenen Tastaturzeichen und auch eingefügte Werte usw. Es akzeptiert nur Ganzzahlen und Die maximale Länge ist die maximale Länge eines Zeichenfolgentyps (was int ist, wirklich lang!)

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

3 Lösung

1)

//Add to the textbox's KeyPress event
//using Regex for number only textBox

private void txtBox_KeyPress(object sender, KeyPressEventArgs e)
{
if (!System.Text.RegularExpressions.Regex.IsMatch(e.KeyChar.ToString(), "\\d+"))
e.Handled = true;
}

2) Eine andere lösung von msdn

// Boolean flag used to determine when a character other than a number is entered.
private bool nonNumberEntered = false;
// Handle the KeyDown event to determine the type of character entered into the     control.
private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
// Initialize the flag to false.
nonNumberEntered = false;
// Determine whether the keystroke is a number from the top of the keyboard.
if (e.KeyCode < Keys.D0 || e.KeyCode > Keys.D9)
{
    // Determine whether the keystroke is a number from the keypad.
    if (e.KeyCode < Keys.NumPad0 || e.KeyCode > Keys.NumPad9)
    {
        // Determine whether the keystroke is a backspace.
        if (e.KeyCode != Keys.Back)
        {
            // A non-numerical keystroke was pressed.
            // Set the flag to true and evaluate in KeyPress event.
            nonNumberEntered = true;
        }
    }
}

}

private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
{
    if (nonNumberEntered == true)
    {
       MessageBox.Show("Please enter number only..."); 
       e.Handled = true;
    }
}

source http://msdn.Microsoft.com/de-de/library/system.windows.forms.control.keypress(v=VS.90).aspx

3) Verwenden der MaskedTextBox: http://msdn.Microsoft.com/en-us/library/system.windows.forms.maskedtextbox.aspx

Ich hatte eine Re-Usable Textbox Extension -Klasse für alle Arten von Überprüfungen erstellt und darüber nachgedacht, sie weiterzugeben.

Sie müssen lediglich ein TextChange-Ereignis auslösen und dann die Validate-Methode aufrufen. Es sieht aus wie das: 

private void tbxAmount_TextChanged(object sender, EventArgs e)
{ 
    tbxAmount.Validate(TextValidator.ValidationType.Amount);
}

Hier ist die Erweiterungsklasse:

public static class TextValidator
{
    public enum ValidationType
    {
        Amount,
        Integer
    }

    /// <summary>
    /// Validate a textbox on text change.
    /// </summary>
    /// <param name="tbx"></param>
    /// <param name="validationType"></param>
    public static void Validate(this TextBox tbx, ValidationType validationType)
    {
        PerformValidation(tbx, validationType);
        tbx.Select(tbx.Text.Length, 0);
    }


    private static void PerformValidation(this TextBox tbx, ValidationType validationType)
    {
        char[] enteredString = tbx.Text.ToCharArray();
        switch (validationType)
        {
            case ValidationType.Amount:
                tbx.Text = AmountValidation(enteredString);
                break;

            case ValidationType.Integer:
                tbx.Text = IntegerValidation(enteredString);
                break;

            default:
                break;
        }

        tbx.SelectionStart = tbx.Text.Length;
    }



    private static string AmountValidation(char[] enteredString)
    {
        string actualString = string.Empty;
        int count = 0;
        foreach (char c in enteredString.AsEnumerable())
        {
            if (count >= 1 && c == '.')
            { actualString.Replace(c, ' '); actualString.Trim(); }
            else
            {
                if (Char.IsDigit(c))
                {
                    actualString = actualString + c;
                }

                if (c == '.')
                {
                    actualString = actualString + c; count++;
                }

                else
                {
                    actualString.Replace(c, ' ');
                    actualString.Trim();
                }
            }
        }
        return actualString;
    }


    private static string IntegerValidation(char[] enteredString)
    {
        string actualString = string.Empty;
        foreach (char c in enteredString.AsEnumerable())
        {
            if (Char.IsDigit(c))
            {
                actualString = actualString + c;
            }
            else
            {
                actualString.Replace(c, ' ');
                actualString.Trim();
            }
        }
        return actualString;
    }
}

Den vollständigen Code finden Sie hier

0
Ozesh

Beim Klicken auf die Schaltfläche können Sie den Text des Textfelds nach der Schleife überprüfen:

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
    }
0
Shaahin