wake-up-neo.net

Erlaube nur bestimmte Zeichen im Textfeld

Wie kann ich nur bestimmte Zeichen in einem Visual C # -Textfeld zulassen? Benutzer sollten in der Lage sein, die folgenden Zeichen in ein Textfeld einzugeben, und alle anderen sollten gesperrt sein: 0-9, +, -, /, *, (,).

Ich habe Google verwendet, um dieses Problem nachzuschlagen, aber die einzige Lösung, die ich bekomme, besteht darin, nur alphabetische Zeichen, nur numerische Zeichen oder bestimmte Zeichen zuzulassen. Was ich möchte, ist, bestimmte Zeichen nicht zuzulassen, ich möchte standardmäßig alles außer den Zeichen, die ich in den Code eingebe, nicht zulassen.

15
Annoying Bot

Wie in einem Kommentar (und einer anderen Antwort bei der Eingabe) erwähnt, müssen Sie einen Ereignishandler registrieren, um das Ereignis keydown oder keypress in einem Textfeld abzufangen. Dies liegt daran, dass TextChanged nur ausgelöst wird, wenn das Textfeld den Fokus verliert

Mit dem folgenden regulären Ausdruck können Sie die Zeichen angeben, die Sie zulassen möchten

Regex regex = new Regex(@"[0-9+\-\/\*\(\)]");
MatchCollection matches = regex.Matches(textValue);

und dies tut das Gegenteil und fängt Zeichen, die nicht erlaubt sind

Regex regex = new Regex(@"[^0-9^+^\-^\/^\*^\(^\)]");
MatchCollection matches = regex.Matches(textValue);

Ich gehe nicht davon aus, dass es eine einzige Übereinstimmung geben wird, da jemand Text in das Textfeld einfügen könnte. In diesem Fall fangen Sie den Text ab

textBox1.TextChanged += new TextChangedEventHandler(textBox1_TextChanged);
private void textBox1_TextChanged(object sender, EventArgs e)
{
    Regex regex = new Regex(@"[^0-9^+^\-^\/^\*^\(^\)]");
    MatchCollection matches = regex.Matches(textBox1.Text);
    if (matches.Count > 0) {
       //tell the user
    }
}

und um einzelne Tastendrucke zu bestätigen

textBox1.KeyPress += new KeyPressEventHandler(textBox1_KeyPress);
private void textBox1_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
{
    // Check for a naughty character in the KeyDown event.
    if (System.Text.RegularExpressions.Regex.IsMatch(e.KeyChar.ToString(), @"[^0-9^+^\-^\/^\*^\(^\)]"))
    {
        // Stop the character from being entered into the control since it is illegal.
        e.Handled = true;
    }
}
23
Paul D'Ambra

Sie müssen das Ereignis KeyDown im Textfeld abonnieren. Dann so etwas wie:

private void textBox1_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
{
    if (!char.IsControl(e.KeyChar) 
       && !char.IsDigit(e.KeyChar) 
       && e.KeyChar != '.' && e.KeyChar != '+' && e.KeyChar != '-'
       && e.KeyChar != '(' && e.KeyChar != ')' && e.KeyChar != '*' 
       && e.KeyChar != '/')
    {
        e.Handled = true;
        return;
    }
    e.Handled=false;
    return;
}

Es ist wichtig zu wissen, dass bei einer Änderung der Handled-Eigenschaft in true der Tastenanschlag nicht verarbeitet wird. Das Festlegen von false wird.

10
Icemanind

Sie können wahrscheinlich das KeyDown-Ereignis , KeyPress-Ereignis oder KeyUp-Ereignis verwenden. Ich würde zuerst das KeyDown-Event versuchen, denke ich.

Sie können die Handled-Eigenschaft der Ereignisargumente so einstellen, dass die Behandlung des Ereignisses beendet wird.

1
Maarten

Intercept the KeyPressed ist meiner Meinung nach eine gute und solide Lösung. Achten Sie auf Triggercode-Zeichen (e.KeyChar niedriger als 32), wenn Sie ein RegExp verwenden.

Auf diese Weise ist es jedoch immer noch möglich, Zeichen außerhalb des Bereichs einzufügen, wenn der Benutzer Text aus der Zwischenablage einfügt. Leider habe ich keine korrekten Zwischenablagen gefunden, um das Problem zu beheben.

Eine wasserdichte Lösung besteht also darin, TextBox.TextChanged abzufangen. Hier ist manchmal das Original außerhalb des Bereichs für kurze Zeit sichtbar. Ich empfehle beide umzusetzen.

using System.Text.RegularExpressions;

private void Form1_Shown(object sender, EventArgs e)
{
    filterTextBoxContent(textBox1);
}


string pattern = @"[^0-9^+^\-^/^*^(^)]";

private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
{
    if(e.KeyChar >= 32 && Regex.Match(e.KeyChar.ToString(), pattern).Success) { e.Handled = true; }
}

private void textBox1_TextChanged(object sender, EventArgs e)
{
    filterTextBoxContent(textBox1);
}

private bool filterTextBoxContent(TextBox textBox)
{
    string text = textBox.Text;

    MatchCollection matches = Regex.Matches(text, pattern);
    bool matched = false;

    int selectionStart = textBox.SelectionStart;
    int selectionLength = textBox.SelectionLength;

    int leftShift = 0;
    foreach (Match match in matches)
    {
        if (match.Success && match.Captures.Count > 0)
        {
            matched = true;
            Capture capture = match.Captures[0];

            int captureLength = capture.Length;
            int captureStart = capture.Index - leftShift;
            int captureEnd = captureStart + captureLength;

            int selectionEnd = selectionStart + selectionLength;

            text = text.Substring(0, captureStart) + text.Substring(captureEnd, text.Length - captureEnd);

            textBox.Text = text;

            int boundSelectionStart = selectionStart < captureStart ? -1 : (selectionStart < captureEnd ? 0 : 1);
            int boundSelectionEnd = selectionEnd < captureStart ? -1 : (selectionEnd < captureEnd ? 0 : 1);

            if (boundSelectionStart == -1)
            {
                if (boundSelectionEnd == 0)
                {
                    selectionLength -= selectionEnd - captureStart;
                }
                else if (boundSelectionEnd == 1)
                {
                    selectionLength -= captureLength;
                }
            }
            else if (boundSelectionStart == 0)
            {
                if (boundSelectionEnd == 0)
                {
                    selectionStart = captureStart;
                    selectionLength = 0;
                }
                else if (boundSelectionEnd == 1)
                {
                    selectionStart = captureStart;
                    selectionLength -= captureEnd - selectionStart;
                }
            }
            else if (boundSelectionStart == 1)
            {
                selectionStart -= captureLength;
            }

            leftShift++;
        }
    }

    textBox.SelectionStart = selectionStart;
    textBox.SelectionLength = selectionLength;

    return matched;
}
0
Martin Wantke

Die einfachste Methode für Ihr Überprüfungsereignis IMO wäre die Verwendung eines Zeichen-Arrays zum Überprüfen von Textfeld-Zeichen. True - Iteration und Validierung sind nicht besonders effizient, aber unkompliziert.

Verwenden Sie alternativ einen regulären Ausdruck Ihrer Whitelist-Zeichen für die Eingabezeichenfolge. Ihre Veranstaltungen finden Sie unter MSDN hier: http://msdn.Microsoft.com/de-de/library/system.windows.forms.control.lostfocus.aspx

0
iivel