Wie bekomme ich eine TextBox nur numerische Eingabe in WPF zu akzeptieren?

Question

Ich möchte Ziffern und das Dezimalkomma akzeptieren, aber kein Vorzeichen.

Ich habe mir Beispiele angesehen, die das NumericUpDown-Steuerelement für Windows Forms verwenden, und dieses Beispiel für ein benutzerdefiniertes Steuerelement NumericUpDown von Microsoft . Aber bisher scheint es wie NumericUpDown (unterstützt von WPF oder nicht) ist nicht gehen, um die Funktionalität, die ich will zu bieten. Die Art und Weise meine Anwendung entworfen ist, niemand bei klarem Verstand wird wollen, um mit den Pfeilen zu verwirren. Sie machen keinen praktischen Sinn, im Kontext meiner Anwendung.

Also ich bin auf der Suche nach einem einfachen Weg, um eine Standard-WPF-TextBox akzeptieren nur die Zeichen, die ich will. Ist dies möglich? Ist es praktisch?

Answer 1

Hier ist eine Bibliothek für numerische Eingaben in WPF

Es hat Eigenschaften wie NumberStyles y RegexPattern für die Validierung.

Unterklassen WPF TextBox

Answer 2

In der WPF-Anwendung können Sie dies behandeln, indem Sie TextChanged Veranstaltung:

void arsDigitTextBox_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
{
    Regex regex = new Regex("[^0-9]+");
    bool handle = regex.IsMatch(this.Text);
    if (handle)
    {
        StringBuilder dd = new StringBuilder();
        int i = -1;
        int cursor = -1;
        foreach (char item in this.Text)
        {
            i++;
            if (char.IsDigit(item))
                dd.Append(item);
            else if(cursor == -1)
                cursor = i;
        }
        this.Text = dd.ToString();

        if (i == -1)
            this.SelectionStart = this.Text.Length;
        else
            this.SelectionStart = cursor;
    }
}

Answer 3

Wenn Sie einen Zahlenwert überprüfen, können Sie die VisualBasic.IsNumeric Funktion.

Answer 4

Nachdem ich einige der Lösungen hier für einige Zeit verwendet habe, habe ich meine eigene entwickelt, die gut für mein MVVM-Setup funktioniert. Beachten Sie, dass es nicht so dynamisch wie einige der anderen in einem Sinne von immer noch erlaubt Benutzern, fehlerhafte Zeichen eingeben, aber es blockiert sie von der Schaltfläche drücken und damit etwas tun. Dies passt gut zu meinem Thema der grauen aus Schaltflächen, wenn Aktionen nicht ausgeführt werden können.

Ich habe eine TextBox dass der Benutzer die Anzahl der zu druckenden Dokumentseiten eingeben muss:

<TextBox Text="{Binding NumberPagesToPrint, UpdateSourceTrigger=PropertyChanged}"/>

...mit dieser verbindlichen Eigenschaft:

private string _numberPagesToPrint;
public string NumberPagesToPrint
{
    get { return _numberPagesToPrint; }
    set
    {
        if (_numberPagesToPrint == value)
        {
            return;
        }

        _numberPagesToPrint = value;
        OnPropertyChanged("NumberPagesToPrint");
    }
}

Ich habe auch eine Schaltfläche:

<Button Template="{DynamicResource CustomButton_Flat}" Content="Set"
        Command="{Binding SetNumberPagesCommand}"/>

...mit dieser Befehlsbindung:

private RelayCommand _setNumberPagesCommand;
public ICommand SetNumberPagesCommand
{
    get
    {
        if (_setNumberPagesCommand == null)
        {
            int num;
            _setNumberPagesCommand = new RelayCommand(param => SetNumberOfPages(),
                () => Int32.TryParse(NumberPagesToPrint, out num));
        }

        return _setNumberPagesCommand;
    }
}

Und dann ist da noch die Methode der SetNumberOfPages() aber das ist für dieses Thema unerheblich. In meinem Fall funktioniert es gut, weil ich keinen Code in die Code-Behind-Datei der View einfügen muss und es mir erlaubt, das Verhalten mit der Command Eigentum.

Answer 5

Für ein einfaches Projekt, an dem ich gearbeitet habe, habe ich mit einer ungebundenen Box gearbeitet, so dass ich den Standardansatz der Bindung nicht verwenden konnte. Daher habe ich einen einfachen Hack erstellt, den andere vielleicht ganz praktisch finden, indem ich einfach das vorhandene TextBox-Steuerelement erweitert habe:

namespace MyApplication.InterfaceSupport
{
    public class NumericTextBox : TextBox
    {

        public NumericTextBox() : base()
        {
            TextChanged += OnTextChanged;
        }

        public void OnTextChanged(object sender, TextChangedEventArgs changed)
        {
            if (!String.IsNullOrWhiteSpace(Text))
            {
                try
                {
                    int value = Convert.ToInt32(Text);
                }
                catch (Exception e)
                {
                    MessageBox.Show(String.Format("{0} only accepts numeric input.", Name));
                    Text = "";
                }
            }
        }

        public int? Value
        {
            set
            {
                if (value != null)
                {
                    this.Text = value.ToString();
                }
                else 
                    Text = "";
            }
            get
            {
                try
                {
                    return Convert.ToInt32(this.Text);
                }
                catch (Exception ef)
                {
                    // Not numeric.
                }
                return null;
            }
        }
    }
}

Für einen fließenden Typ würden Sie ihn natürlich als Float analysieren wollen und so weiter. Es gelten die gleichen Grundsätze.

Dann müssen Sie in der XAML-Datei den entsprechenden Namespace einschließen:

<UserControl x:Class="MyApplication.UserControls.UnParameterisedControl"
             [ Snip ]
             xmlns:interfaceSupport="clr-namespace:MyApplication.InterfaceSupport"
             >

Danach können Sie es als reguläre Kontrolle verwenden:

<interfaceSupport:NumericTextBox Height="23" HorizontalAlignment="Left" Margin="168,51,0,0" x:Name="NumericBox" VerticalAlignment="Top" Width="120" >