C# TextBox filtern

Möchte ich die Daten filtern, die der Benutzer eingibt. Ich will nur ihn, um in der Lage sein, um zahlen zu addieren und , oder . und zum löschen im Fall des Irrtums.

Habe ich diesen code:

private void textBox_KeyPress(object sender, KeyPressEventArgs e)
{
    if ((char.IsDigit(e.KeyChar) == false) && 
        (e.KeyChar != '\b') && (e.KeyChar != ',')) 
            e.Handled = true;
    if (e.KeyChar == ',' && (sender as TextBox).Text.IndexOf(',') > 0) 
        e.Handled = true;
}

Nun habe ich zwei Probleme:
1) ich habe zwei Textfelder (die Felder wo der Benutzer schreiben darf einige zahlen, die Hinzugefügt werden/geteilt usw.) und wenn ich Schreibe nur ein Komma in einem von Ihnen gibt es einen Fehler.
2) ich möchte auch, um es möglich zu verwenden ".", aber ich will es ändern in ",".

Welche Fehlermeldung erhalten Sie?
Unbehandelte Ausnahme
Verwenden Sie eine MaskedTextBox-Steuerelement statt.
Betrachten Sie die Fragen zu diesem ein und Sie werden sehen, eine Menge von Duplikaten.
JEDE Ausnahme, die Sie erhalten, wird nicht behandelt, was ist die exception-Meldung?

InformationsquelleAutor Jeling | 2014-05-30

c#filter textbox

Mehrere Steuerelemente können auf den gleichen event-handler, so dass die Anzahl der Textfelder ist irrelevant.
Ersetzen ein Zeichen getan werden kann, einfach durch Zuweisung des gewünschten Wertes für e ist.KeyChar

Dieser code ermöglicht Kommas ohne Ausnahme:

private void textBox_KeyPress(object sender, KeyPressEventArgs e)
{
    if (!char.IsDigit(e.KeyChar) && e.KeyChar != ',' && e.KeyChar != '.')
    {
        e.Handled = true;
    }
    else if (e.KeyChar == '.')
    {
        e.KeyChar = ',';
    }
}

Dennoch, mit Blick auf Ihren code, es scheint, dass Sie möchten, dass nur ein einzelnes Komma. Dieser code beschränkt den Inhalt, die nur ein einzelnes Komma:

private void textBox_KeyPress(object sender, KeyPressEventArgs e)
{
    if (!char.IsDigit(e.KeyChar) && e.KeyChar != ',' && e.KeyChar != '.')
    {
        e.Handled = true;
    }
    else if (e.KeyChar == '.')
    {
        e.KeyChar = ',';
    }
    if (e.KeyChar == ',')
    {
        //can use .Contains, indexOf, etc.  I used count incase you want more than 1
        if(((TextBox) sender).Text.Count(s=>s==',') == 1)
        {
            e.Handled = true;
        }
    }
}

Offenbar, ich weiß nicht, wie format-code in den Kommentaren, so ich aktualisiere die wichtigste Antwort, um Platz für die zusätzliche Anforderung.
Dieser code erlaubt - aber die stellen es an den Anfang der Reihe unabhängig davon, wenn es gedrückt wird:

if (!char.IsDigit(e.KeyChar) && e.KeyChar != ',' && e.KeyChar != '.' && e.KeyChar != '-')
{
    e.Handled = true;
}
else if (e.KeyChar == '.')
{
    e.KeyChar = ',';
}
else if (e.KeyChar == '-')
{
    if (((TextBox) sender).Text.Contains("-"))
    {
        e.Handled = true;
    }
    else
    {
        ((TextBox) sender).Text = "-" + ((TextBox) sender).Text;
        e.Handled = true;
    }
}
if (e.KeyChar == ',')
{
    if(((TextBox) sender).Text.Count(s=>s==',') == 1)
    {
        e.Handled = true;
    }
}

Toll, das hat mir sehr geholfen. Und ich habe nur eine weitere Sache, die ich dachte nur: "-" erlaubt sein sollte, nur am Anfang...
Ich aktualisiert die ursprüngliche "Antwort" - post mit der zusätzlichen Bedingung, weil ich es nicht geschafft, die code Formatierung zu arbeiten, in einem Kommentar.

InformationsquelleAutor Lemiarty

Hier ist der code, den ich schrieb, mit WndProc um so Priorität wie möglich abzufangen, Veranstaltungen, und Sie den code unten behandelt, indem auf die Taste drücken, wird das einfügen und einstellen von text programmgesteuert.

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace NetTools.GUI
{

    public class FastTextBox : TextBox
    {

        [DebuggerHidden, DebuggerNonUserCode, DllImport("user32.dll")]
        private static extern IntPtr SendMessage(IntPtr hWnd, int Msg, int wParam, [MarshalAs(UnmanagedType.LPWStr)] string lParam);

        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private string hint = string.Empty;

        ///<summary>
        ///Is called in preview the system handle the changes, and determines whether the text will be accepted and handled by the system.
        ///</summary>
        ///<param name="oldText">The old text.</param>
        ///<param name="newText">The current text (included the newer changes).</param>
        ///<param name="input">The newer changes.</param>
        ///<param name="offset">Start position of changes.</param>
        ///<param name="length">Length of <paramref name="input"/>.</param>
        ///<returns>Whether the system can handle the text.</returns>
        public delegate bool TextAcceptorEventHandler(string oldText, string newText, string input, int offset, int length);

        ///<summary>
        ///Is called in preview of or after the system handle the changes.
        ///</summary>
        ///<param name="oldText">The old text.</param>
        ///<param name="newText">The current text (included the newer changes).</param>
        ///<param name="input">The newer changes.</param>
        ///<param name="offset">Start position of changes.</param>
        ///<param name="length">Length of <paramref name="input"/>.</param>
        public delegate void TextEventHandler(string oldText, string newText, string input, int offset, int length);

        ///<summary>
        ///Is called in preview of the system handle the changes.
        ///</summary>
        public event TextEventHandler PreviewTextChange = null;

        ///<summary>
        ///Is called after the system handled the changes.
        ///</summary>
        public event TextEventHandler AfterTextChange = null;

        public string Hint
        {
            [DebuggerHidden]
            get
            {
                return hint;
            }
            [DebuggerHidden]
            set
            {
                if (value == hint)
                    return;
                hint = value;
                SendMessage(Handle, 0x1501, 1, value);
            }
        }

        public TextAcceptorEventHandler TextAcceptor
        {
            [DebuggerHidden]
            get;
            [DebuggerHidden]
            set;
        }

        [DebuggerHidden]
        protected override void CreateHandle()
        {
            base.CreateHandle();
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw | ControlStyles.FixedWidth | ControlStyles.FixedHeight | ControlStyles.Opaque, DoubleBuffered = true);
        }

        ///<summary>
        ///Is called in preview of a text change, before the system handles it, and determines whether the text will be accepted and handled by system.
        ///</summary>
        ///<param name="oldText">The last written text.</param>
        ///<param name="newText">The current text (included the newer changes).</param>
        ///<param name="input">The newer changes.</param>
        ///<param name="offset">Start position of changes.</param>
        ///<param name="length">Length of <paramref name="input"/>.</param>
        ///<returns></returns>
        [DebuggerHidden]
        protected virtual bool OnAcceptTextInput(string oldText, string newText, string input, int offset, int length)
        {
            return TextAcceptor == null ? true : TextAcceptor.Invoke(oldText, newText, input, offset, length);
        }

        ///<summary>
        ///Is called in preview of a text change, before the system handles it.
        ///</summary>
        ///<param name="oldText">The last written text.</param>
        ///<param name="newText">The current text (included the newer changes).</param>
        ///<param name="input">The newer changes.</param>
        ///<param name="offset">Start position of changes.</param>
        ///<param name="length">Length of <paramref name="input"/>.</param>
        [DebuggerHidden]
        protected virtual void OnPreviewTextChange(string oldText, string newText, string input, int offset, int length)
        {
            if (PreviewTextChange != null)
                PreviewTextChange.Invoke(oldText, newText, input, offset, length);
        }

        ///<summary>
        ///Is called after the system handled the changes.
        ///</summary>
        ///<param name="oldText">The old text.</param>
        ///<param name="newText">The current text (included the newer changes).</param>
        ///<param name="input">The newer changes.</param>
        ///<param name="offset">Start position of changes.</param>
        ///<param name="length">Length of <paramref name="input"/>.</param>
        [DebuggerHidden]
        protected virtual void OnAfterTextChange(string oldText, string newText, string input, int offset, int length)
        {
            if (AfterTextChange != null)
                AfterTextChange.Invoke(oldText, newText, input, offset, length);
        }

        [DebuggerHidden]
        private bool CallbackPreview(string oldText, string newText, string input, int offset, int length)
        {
            if (string.IsNullOrEmpty(newText) ? true : OnAcceptTextInput(oldText, newText, input, offset, length))
            {
                OnPreviewTextChange(oldText, newText, input, offset, length);
                return true;
            }
            return false;
        }

        [DebuggerHidden]
        private bool CallbackPreview(ref string newText, string oldText, string input, int offset, int length)
        {
            newText = GetNewText(oldText, input, offset, length);
            return CallbackPreview(oldText, newText, input, offset, length);
        }

        [DebuggerHidden]
        private string GetNewText(string oldText, string input, int offset, int length)
        {
            if (input.Length == 1 ? input.ToCharArray()[0] == (int)Keys.Back : false)
                return Text.Length > 0 ? $"{oldText.Substring(0, offset - (length == 0 ? 1 : 0))}{oldText.Substring(offset + length)}" : string.Empty;
            else
                return $"{(offset > 0 ? oldText.Substring(0, offset) : string.Empty)}{input}{(offset == oldText.Length - 1 ? string.Empty : oldText.Substring(offset + length))}";
        }

        [DebuggerHidden]
        protected override void WndProc(ref Message m)
        {
            string text = "";
            switch (m.Msg)
            {
                case 0x102:
                    int code = m.WParam.ToInt32();
                    if (code == 22 && ModifierKeys.HasFlag(Keys.Control))
                        goto case 0x302;
                    text = ((char)code).ToString();
                    goto case 0xC;
                case 0x302:
                    text = Clipboard.GetText();
                    goto case 0xC;
                case 0xC:
                    string input = string.Empty, newText = string.Empty;
                    if (string.IsNullOrEmpty(text))
                    {
                        newText = Marshal.PtrToStringUni(m.LParam);
                        if (CallbackPreview(Text, newText, string.Empty, SelectionStart, SelectionLength))
                            base.WndProc(ref m);
                    } else
                    {
                        input = text;
                        if (CallbackPreview(ref newText, Text, input, SelectionStart, SelectionLength))
                            base.WndProc(ref m);
                    }
                    OnAfterTextChange(Text, newText, input, SelectionStart, SelectionLength);
                    break;
                default:
                    base.WndProc(ref m);
                    break;
            }
        }
    }
}

Dann können Sie einfach FastTextBox als Kontrolle, im Ort der TextBox, und legen Sie programmgesteuert die TextAcceptor Eigenschaft eines Delegierten:

yourFastTextBox.TextAcceptor = yourTextAcceptorDelegate;

private bool CidrTextAcceptor(string oldText, string newText, string input, int offset, int length)
{
    return whether the text can be wrote or not.
}

Für weitere Erklärungen finden Sie in der Dokumentation schrieb ich in der Klasse.

EDIT:
Ich verbesserte den code, basierend auf einem bug mit der Zwischenablage.

InformationsquelleAutor Davide Cannizzo

Können Sie verwenden regex + text changed event. Es ist sehr einfache in Ihrem Fall:

static string regexPattern = "[^0-9.,]";
Regex regex = new Regex(regexPattern);

private void myTextBox_TextChanged(object sender, EventArgs e)
{
    myTextBox.Text = regex.Replace(myTextBox.Text, "").Replace(".", ",");
}

InformationsquelleAutor Phoenix

Haben Sie sich Gedanken über die Verwendung Regular expression validator und textbox in Ihrer aspx-Seite?

<asp:TextBox ID="txtDevice" runat="server" Text="sample"></asp:TextBox>
                <asp:RegularExpressionValidator ID="revDeviceTextBnd" Text="*" Display="Dynamic"  runat="server" ControlToValidate="txtDevice" ValidationExpression="Your regex goes here" ValidationGroup="onBnd" >
</asp:RegularExpressionValidator>

Dies ist nur ein weiterer Ansatz, obwohl.

InformationsquelleAutor Rex

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.