Wie kann ich eine TextBox dazu bringen, nur numerische Eingaben in WPF zu akzeptieren?

Ich möchte Ziffern und den Dezimalpunkt akzeptieren, aber kein Vorzeichen.

Ich habe mir Beispiele mit dem NumericUpDown-Steuerelement für Windows Forms und dieses Beispiel eines benutzerdefinierten NumericUpDown-Steuerelements von Microsoft angesehen . Bisher scheint es jedoch so, als würde NumericUpDown (von WPF unterstützt oder nicht) nicht die gewünschte Funktionalität bieten. So wie meine Anwendung gestaltet ist, wird niemand, der bei klarem Verstand ist, mit den Pfeilen herumspielen wollen. Sie ergeben im Rahmen meiner Bewerbung keinen praktischen Sinn.

Daher suche ich nach einer einfachen Möglichkeit, eine Standard-WPF-Textbox so zu gestalten, dass sie nur die gewünschten Zeichen akzeptiert. Ist das möglich? Ist es praktisch?

Fügen Sie ein Vorschau-Texteingabeereignis hinzu. Wie so : <TextBox PreviewTextInput="PreviewTextInput" />.

Dann in diesem Set die, e.Handledwenn der Text nicht erlaubt ist.e.Handled = !IsTextAllowed(e.Text);

Ich verwende eine einfache Regex- IsTextAllowedMethode, um zu sehen, ob ich zulassen soll, was sie eingegeben haben. In meinem Fall möchte ich nur Zahlen, Punkte und Striche zulassen.

private static readonly Regex _regex = new Regex("[^0-9.-]+"); //regex that matches disallowed text
private static bool IsTextAllowed(string text)
{
    return !_regex.IsMatch(text);
}

Wenn Sie das Einfügen falscher Daten verhindern möchten, schließen Sie das DataObject.PastingEreignis DataObject.Pasting="TextBoxPasting"wie hier gezeigt an (Code-Auszug):

// Use the DataObject.Pasting Handler 
private void TextBoxPasting(object sender, DataObjectPastingEventArgs e)
{
    if (e.DataObject.GetDataPresent(typeof(String)))
    {
        String text = (String)e.DataObject.GetData(typeof(String));
        if (!IsTextAllowed(text))
        {
            e.CancelCommand();
        }
    }
    else
    {
        e.CancelCommand();
    }
}

Der Ereignishandler zeigt eine Vorschau der Texteingabe an. Hier stimmt ein regulärer Ausdruck nur dann mit der Texteingabe überein, wenn es sich nicht um eine Zahl handelt, und wird dann nicht zum Eingabe-Textfeld gemacht.

Wenn Sie nur Buchstaben möchten, ersetzen Sie den regulären Ausdruck als [^a-zA-Z].

XAML

<TextBox Name="NumberTextBox" PreviewTextInput="NumberValidationTextBox"/>

XAML.CS-DATEI

using System.Text.RegularExpressions;
private void NumberValidationTextBox(object sender, TextCompositionEventArgs e)
{
    Regex regex = new Regex("[^0-9]+");
    e.Handled = regex.IsMatch(e.Text);
}

Ich habe einiges von dem verwendet, was bereits hier war, und es mit einem Verhalten selbst verändert, damit ich diesen Code nicht über eine Tonne von Ansichten hinweg verbreiten muss ...

public class AllowableCharactersTextBoxBehavior : Behavior<TextBox>
{
    public static readonly DependencyProperty RegularExpressionProperty =
         DependencyProperty.Register("RegularExpression", typeof(string), typeof(AllowableCharactersTextBoxBehavior),
         new FrameworkPropertyMetadata(".*"));
    public string RegularExpression
    {
        get
        {
            return (string)base.GetValue(RegularExpressionProperty);
        }
        set
        {
            base.SetValue(RegularExpressionProperty, value);
        }
    }

    public static readonly DependencyProperty MaxLengthProperty =
        DependencyProperty.Register("MaxLength", typeof(int), typeof(AllowableCharactersTextBoxBehavior),
        new FrameworkPropertyMetadata(int.MinValue));
    public int MaxLength
    {
        get
        {
            return (int)base.GetValue(MaxLengthProperty);
        }
        set
        {
            base.SetValue(MaxLengthProperty, value);
        }
    }

    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.PreviewTextInput += OnPreviewTextInput;
        DataObject.AddPastingHandler(AssociatedObject, OnPaste);
    }

    private void OnPaste(object sender, DataObjectPastingEventArgs e)
    {
        if (e.DataObject.GetDataPresent(DataFormats.Text))
        {
            string text = Convert.ToString(e.DataObject.GetData(DataFormats.Text));

            if (!IsValid(text, true))
            {
                e.CancelCommand();
            }
        }
        else
        {
            e.CancelCommand();
        }
    }

    void OnPreviewTextInput(object sender, System.Windows.Input.TextCompositionEventArgs e)
    {
        e.Handled = !IsValid(e.Text, false);
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.PreviewTextInput -= OnPreviewTextInput;
        DataObject.RemovePastingHandler(AssociatedObject, OnPaste);
    }

    private bool IsValid(string newText, bool paste)
    {
        return !ExceedsMaxLength(newText, paste) && Regex.IsMatch(newText, RegularExpression);
    }

    private bool ExceedsMaxLength(string newText, bool paste)
    {
        if (MaxLength == 0) return false;

        return LengthOfModifiedText(newText, paste) > MaxLength;
    }

    private int LengthOfModifiedText(string newText, bool paste)
    {
        var countOfSelectedChars = this.AssociatedObject.SelectedText.Length;
        var caretIndex = this.AssociatedObject.CaretIndex;
        string text = this.AssociatedObject.Text;

        if (countOfSelectedChars > 0 || paste)
        {
            text = text.Remove(caretIndex, countOfSelectedChars);
            return text.Length + newText.Length;
        }
        else
        {
            var insert = Keyboard.IsKeyToggled(Key.Insert);

            return insert && caretIndex < text.Length ? text.Length : text.Length + newText.Length;
        }
    }
}

Hier ist der relevante Ansichtscode:

<TextBox MaxLength="50" TextWrapping="Wrap" MaxWidth="150" Margin="4"
 Text="{Binding Path=FileNameToPublish}" >
     <interactivity:Interaction.Behaviors>
         <v:AllowableCharactersTextBoxBehavior RegularExpression="^[0-9.\-]+$" MaxLength="50" />
     </interactivity:Interaction.Behaviors>
</TextBox>

Dies ist eine verbesserte Lösung der Antwort von WilP . Meine Verbesserungen sind:

• Verbessertes Verhalten auf den Schaltflächen Entf und Rücktaste
• EmptyValueEigenschaft hinzugefügt , wenn leere Zeichenfolge unangemessen ist
• Einige kleinere Tippfehler wurden behoben

/// <summary>
///     Regular expression for Textbox with properties: 
///         <see cref="RegularExpression"/>, 
///         <see cref="MaxLength"/>,
///         <see cref="EmptyValue"/>.
/// </summary>
public class TextBoxInputRegExBehaviour : Behavior<TextBox>
{
    #region DependencyProperties
    public static readonly DependencyProperty RegularExpressionProperty =
        DependencyProperty.Register("RegularExpression", typeof(string), typeof(TextBoxInputRegExBehaviour), new FrameworkPropertyMetadata(".*"));

    public string RegularExpression
    {
        get { return (string)GetValue(RegularExpressionProperty); }
        set { SetValue(RegularExpressionProperty, value); }
    }

    public static readonly DependencyProperty MaxLengthProperty =
        DependencyProperty.Register("MaxLength", typeof(int), typeof(TextBoxInputRegExBehaviour),
                                        new FrameworkPropertyMetadata(int.MinValue));

    public int MaxLength
    {
        get { return (int)GetValue(MaxLengthProperty); }
        set { SetValue(MaxLengthProperty, value); }
    }

    public static readonly DependencyProperty EmptyValueProperty =
        DependencyProperty.Register("EmptyValue", typeof(string), typeof(TextBoxInputRegExBehaviour), null);

    public string EmptyValue
    {
        get { return (string)GetValue(EmptyValueProperty); }
        set { SetValue(EmptyValueProperty, value); }
    }
    #endregion

    /// <summary>
    ///     Attach our behaviour. Add event handlers
    /// </summary>
    protected override void OnAttached()
    {
        base.OnAttached();

        AssociatedObject.PreviewTextInput += PreviewTextInputHandler;
        AssociatedObject.PreviewKeyDown += PreviewKeyDownHandler;
        DataObject.AddPastingHandler(AssociatedObject, PastingHandler);
    }

    /// <summary>
    ///     Deattach our behaviour. remove event handlers
    /// </summary>
    protected override void OnDetaching()
    {
        base.OnDetaching();

        AssociatedObject.PreviewTextInput -= PreviewTextInputHandler;
        AssociatedObject.PreviewKeyDown -= PreviewKeyDownHandler;
        DataObject.RemovePastingHandler(AssociatedObject, PastingHandler);
    }

    #region Event handlers [PRIVATE] --------------------------------------

    void PreviewTextInputHandler(object sender, TextCompositionEventArgs e)
    {
        string text;
        if (this.AssociatedObject.Text.Length < this.AssociatedObject.CaretIndex)
            text = this.AssociatedObject.Text;
        else
        {
            //  Remaining text after removing selected text.
            string remainingTextAfterRemoveSelection;

            text = TreatSelectedText(out remainingTextAfterRemoveSelection)
                ? remainingTextAfterRemoveSelection.Insert(AssociatedObject.SelectionStart, e.Text)
                : AssociatedObject.Text.Insert(this.AssociatedObject.CaretIndex, e.Text);
        }

        e.Handled = !ValidateText(text);
    }

    /// <summary>
    ///     PreviewKeyDown event handler
    /// </summary>
    void PreviewKeyDownHandler(object sender, KeyEventArgs e)
    {
        if (string.IsNullOrEmpty(this.EmptyValue))
            return;

        string text = null;

        // Handle the Backspace key
        if (e.Key == Key.Back)
        {
            if (!this.TreatSelectedText(out text))
            {
                if (AssociatedObject.SelectionStart > 0)
                    text = this.AssociatedObject.Text.Remove(AssociatedObject.SelectionStart - 1, 1);
            }
        }
        // Handle the Delete key
        else if (e.Key == Key.Delete)
        {
            // If text was selected, delete it
            if (!this.TreatSelectedText(out text) && this.AssociatedObject.Text.Length > AssociatedObject.SelectionStart)
            {
                // Otherwise delete next symbol
                text = this.AssociatedObject.Text.Remove(AssociatedObject.SelectionStart, 1);
            }
        }

        if (text == string.Empty)
        {
            this.AssociatedObject.Text = this.EmptyValue;
            if (e.Key == Key.Back)
                AssociatedObject.SelectionStart++;
            e.Handled = true;
        }
    }

    private void PastingHandler(object sender, DataObjectPastingEventArgs e)
    {
        if (e.DataObject.GetDataPresent(DataFormats.Text))
        {
            string text = Convert.ToString(e.DataObject.GetData(DataFormats.Text));

            if (!ValidateText(text))
                e.CancelCommand();
        }
        else
            e.CancelCommand();
    }
    #endregion Event handlers [PRIVATE] -----------------------------------

    #region Auxiliary methods [PRIVATE] -----------------------------------

    /// <summary>
    ///     Validate certain text by our regular expression and text length conditions
    /// </summary>
    /// <param name="text"> Text for validation </param>
    /// <returns> True - valid, False - invalid </returns>
    private bool ValidateText(string text)
    {
        return (new Regex(this.RegularExpression, RegexOptions.IgnoreCase)).IsMatch(text) && (MaxLength == int.MinValue || text.Length <= MaxLength);
    }

    /// <summary>
    ///     Handle text selection
    /// </summary>
    /// <returns>true if the character was successfully removed; otherwise, false. </returns>
    private bool TreatSelectedText(out string text)
    {
        text = null;
        if (AssociatedObject.SelectionLength <= 0) 
            return false;

        var length = this.AssociatedObject.Text.Length;
        if (AssociatedObject.SelectionStart >= length)
            return true;

        if (AssociatedObject.SelectionStart + AssociatedObject.SelectionLength >= length)
            AssociatedObject.SelectionLength = length - AssociatedObject.SelectionStart;

        text = this.AssociatedObject.Text.Remove(AssociatedObject.SelectionStart, AssociatedObject.SelectionLength);
        return true;
    }
    #endregion Auxiliary methods [PRIVATE] --------------------------------
}

Die Verwendung ist ziemlich einfach:

<i:Interaction.Behaviors>
    <behaviours:TextBoxInputRegExBehaviour RegularExpression="^\d+$" MaxLength="9" EmptyValue="0" />
</i:Interaction.Behaviors>

Hier ist eine sehr einfache und einfache Möglichkeit, dies mit MVVM zu tun.

Binden Sie Ihre TextBox mit einer Ganzzahl-Eigenschaft im Ansichtsmodell, und dies funktioniert wie ein Juwel. Es wird sogar die Validierung angezeigt, wenn eine Nicht-Ganzzahl in das Textfeld eingegeben wird.

XAML-Code:

<TextBox x:Name="contactNoTxtBox"  Text="{Binding contactNo}" />

Modellcode anzeigen:

private long _contactNo;
public long contactNo
{
    get { return _contactNo; }
    set
    {
        if (value == _contactNo)
            return;
        _contactNo = value;
        OnPropertyChanged();
    }
}

Fügen Sie eine GÜLTIGKEITSREGEL hinzu, damit Sie bei einer Textänderung überprüfen können, ob die Daten numerisch sind. Wenn dies der Fall ist, kann die Verarbeitung fortgesetzt werden. Wenn dies nicht der Fall ist, wird der Benutzer aufgefordert, nur numerische Daten in diesem Feld zu akzeptieren.

Weitere Informationen finden Sie unter Validierung in Windows Presentation Foundation

Das Extented WPF Toolkit verfügt über eines: NumericUpDown

Könnte auch einfach eine Validierungsregel implementieren und auf die TextBox anwenden:

  <TextBox>
    <TextBox.Text>
      <Binding Path="OnyDigitInput" Mode="TwoWay" UpdateSourceTrigger="PropertyChanged">
        <Binding.ValidationRules>
          <conv:OnlyDigitsValidationRule />
        </Binding.ValidationRules>
      </Binding>
    </TextBox.Text>

Mit der Implementierung der Regel wie folgt (unter Verwendung des gleichen Regex wie in anderen Antworten vorgeschlagen):

public class OnlyDigitsValidationRule : ValidationRule
{
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        var validationResult = new ValidationResult(true, null);

        if(value != null)
        {
            if (!string.IsNullOrEmpty(value.ToString()))
            {
                var regex = new Regex("[^0-9.-]+"); //regex that matches disallowed text
                var parsingOk = !regex.IsMatch(value.ToString());
                if (!parsingOk)
                {
                    validationResult = new ValidationResult(false, "Illegal Characters, Please Enter Numeric Value");
                }
            }
        }

        return validationResult;
    }
}

Hier habe ich eine einfache Lösung inspiriert von Rays Antwort ist . Dies sollte ausreichen, um jede Form von Nummer zu identifizieren.

Diese Lösung kann auch leicht geändert werden, wenn Sie nur positive Zahlen, ganzzahlige Werte oder Werte mit einer maximalen Anzahl von Dezimalstellen usw. wünschen.

Wie in Rays Antwort vorgeschlagen , müssen Sie zuerst ein PreviewTextInputEreignis hinzufügen :

<TextBox PreviewTextInput="TextBox_OnPreviewTextInput"/>

Fügen Sie dann Folgendes in den Code dahinter ein:

private void TextBox_OnPreviewTextInput(object sender, TextCompositionEventArgs e)
{
    var textBox = sender as TextBox;
    // Use SelectionStart property to find the caret position.
    // Insert the previewed text into the existing text in the textbox.
    var fullText = textBox.Text.Insert(textBox.SelectionStart, e.Text);

    double val;
    // If parsing is successful, set Handled to false
    e.Handled = !double.TryParse(fullText, out val);
}

Ich erlaubte Ziffernblocknummern und Rücktaste:

    private void TextBox_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        int key = (int)e.Key;

        e.Handled = !(key >= 34 && key <= 43 || 
                      key >= 74 && key <= 83 || 
                      key == 2);
    }

Ich gehe davon aus, dass:

1. In Ihrer TextBox, für die Sie nur numerische Eingaben zulassen möchten, ist die Eigenschaft Text zunächst auf einen gültigen Zahlenwert festgelegt (z. B. 2.7172).

2. Ihre Textbox ist ein untergeordnetes Element Ihres Hauptfensters

3. Ihr Hauptfenster ist von der Klasse Window1

4. Ihr TextBox-Name ist numericTB

Grundidee:

1. Hinzufügen: private string previousText;zu Ihrer Hauptfensterklasse (Window1)

2. Hinzufügen: previousText = numericTB.Text;zu Ihrem Hauptfensterkonstruktor

3. Erstellen Sie einen Handler für das numericTB.TextChanged-Ereignis, der ungefähr so ​​aussieht:

   private void numericTB_TextChanged(object sender, TextChangedEventArgs e)
   {
       double num = 0;
       bool success = double.TryParse(((TextBox)sender).Text, out num);
       if (success & num >= 0)
           previousText = ((TextBox)sender).Text;
       else
           ((TextBox)sender).Text = previousText;
   }

Dadurch wird previousText so lange wie möglich auf numericTB.Text gesetzt und numericTB.Text auf den letzten gültigen Wert gesetzt, wenn der Benutzer etwas schreibt, das Ihnen nicht gefällt. Natürlich ist dies nur eine Grundidee, und es ist nur "idiotenresistent", nicht "idiotensicher". Der Fall, in dem der Benutzer beispielsweise mit Leerzeichen herumspielt, wird nicht behandelt. Hier ist also eine vollständige Lösung, die ich für "idiotensicher" halte. Wenn ich falsch liege, sagen Sie mir bitte:

1. Inhalt Ihrer Window1.xaml-Datei:

   <Window x:Class="IdiotProofNumericTextBox.Window1"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       Title="Window1" Height="300" Width="300">
       <Grid>
           <TextBox Height="30" Width="100" Name="numericTB" TextChanged="numericTB_TextChanged"/>
       </Grid>
   </Window>

2. Inhalt Ihrer Window.xaml.cs-Datei:

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Windows;
   using System.Windows.Controls;
   using System.Windows.Data;
   using System.Windows.Documents;
   using System.Windows.Input;
   using System.Windows.Media;
   using System.Windows.Media.Imaging;
   using System.Windows.Navigation;
   using System.Windows.Shapes;
   
   namespace IdiotProofNumericTextBox
   {
       public partial class Window1 : Window
       {
           private string previousText;
   
           public Window1()
           {
               InitializeComponent();
               previousText = numericTB.Text;
           }
   
           private void numericTB_TextChanged(object sender, TextChangedEventArgs e)
           {
               if (string.IsNullOrEmpty(((TextBox)sender).Text))
                   previousText = "";
               else
               {
                   double num = 0;
                   bool success = double.TryParse(((TextBox)sender).Text, out num);
                   if (success & num >= 0)
                   {
                       ((TextBox)sender).Text.Trim();
                       previousText = ((TextBox)sender).Text;
                   }
                   else
                   {
                       ((TextBox)sender).Text = previousText;
                       ((TextBox)sender).SelectionStart = ((TextBox)sender).Text.Length;
                   }
               }
           }
       }
   }

Und das ist es. Wenn Sie viele TextBoxen haben, empfehle ich, ein CustomControl zu erstellen, das von TextBox erbt, damit Sie previousText und numericTB_TextChanged in einer separaten Datei zusammenfassen können.

Dies ist der einzige Code, der benötigt wird:

void MyTextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    e.Handled = new Regex("[^0-9]+").IsMatch(e.Text);
}

Dadurch können nur Zahlen in das Textfeld eingegeben werden.

Um einen Dezimalpunkt oder ein Minuszeichen zuzulassen, können Sie den regulären Ausdruck in ändern [^0-9.-]+.

Wenn Sie nicht viel Code schreiben möchten, um eine Grundfunktion auszuführen (ich weiß nicht, warum Leute lange Methoden anwenden), können Sie dies einfach tun:

1. Namespace hinzufügen:

   using System.Text.RegularExpressions;

2. Legen Sie in XAML eine TextChanged-Eigenschaft fest:

   <TextBox x:Name="txt1" TextChanged="txt1_TextChanged"/>

3. Fügen Sie in WPF unter der Methode txt1_TextChanged Folgendes hinzu Regex.Replace:

   private void txt1_TextChanged(object sender, TextChangedEventArgs e)
   {
       txt1.Text = Regex.Replace(txt1.Text, "[^0-9]+", "");
   }

Ein anderer Ansatz ist die Verwendung eines angehängten Verhaltens. Ich habe meine benutzerdefinierte TextBoxHelper- Klasse implementiert , die für Textfelder in meinem gesamten Projekt verwendet werden kann. Weil ich mir gedacht habe, dass das Abonnieren der Ereignisse für jedes Textfeld und für jede einzelne XAML-Datei zu diesem Zweck zeitaufwändig sein kann.

Die von mir implementierte TextBoxHelper-Klasse verfügt über folgende Funktionen:

• Filtern und Akzeptieren nur von Zahlen in Double , Int , Uint und Natural Format
• Filterung und nur akzeptieren Selbst oder Odd Zahlen
• Handler zum Einfügen von Ereignissen , um zu verhindern, dass ungültiger Text in unsere numerischen Textfelder eingefügt wird
• Kann einen Standardwert festlegen , der verwendet wird, um ungültige Daten als letzte Aufnahme zu verhindern, indem das Textfeld TextChanged-Ereignis abonniert wird

Hier ist die Implementierung der TextBoxHelper-Klasse:

public static class TextBoxHelper
{
    #region Enum Declarations

    public enum NumericFormat
    {
        Double,
        Int,
        Uint,
        Natural
    }

    public enum EvenOddConstraint
    {
        All,
        OnlyEven,
        OnlyOdd
    }

    #endregion

    #region Dependency Properties & CLR Wrappers

    public static readonly DependencyProperty OnlyNumericProperty =
        DependencyProperty.RegisterAttached("OnlyNumeric", typeof(NumericFormat?), typeof(TextBoxHelper),
            new PropertyMetadata(null, DependencyPropertiesChanged));
    public static void SetOnlyNumeric(TextBox element, NumericFormat value) =>
        element.SetValue(OnlyNumericProperty, value);
    public static NumericFormat GetOnlyNumeric(TextBox element) =>
        (NumericFormat) element.GetValue(OnlyNumericProperty);


    public static readonly DependencyProperty DefaultValueProperty =
        DependencyProperty.RegisterAttached("DefaultValue", typeof(string), typeof(TextBoxHelper),
            new PropertyMetadata(null, DependencyPropertiesChanged));
    public static void SetDefaultValue(TextBox element, string value) =>
        element.SetValue(DefaultValueProperty, value);
    public static string GetDefaultValue(TextBox element) => (string) element.GetValue(DefaultValueProperty);


    public static readonly DependencyProperty EvenOddConstraintProperty =
        DependencyProperty.RegisterAttached("EvenOddConstraint", typeof(EvenOddConstraint), typeof(TextBoxHelper),
            new PropertyMetadata(EvenOddConstraint.All, DependencyPropertiesChanged));
    public static void SetEvenOddConstraint(TextBox element, EvenOddConstraint value) =>
        element.SetValue(EvenOddConstraintProperty, value);
    public static EvenOddConstraint GetEvenOddConstraint(TextBox element) =>
        (EvenOddConstraint)element.GetValue(EvenOddConstraintProperty);

    #endregion

    #region Dependency Properties Methods

    private static void DependencyPropertiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (!(d is TextBox textBox))
            throw new Exception("Attached property must be used with TextBox.");

        switch (e.Property.Name)
        {
            case "OnlyNumeric":
            {
                var castedValue = (NumericFormat?) e.NewValue;

                if (castedValue.HasValue)
                {
                    textBox.PreviewTextInput += TextBox_PreviewTextInput;
                    DataObject.AddPastingHandler(textBox, TextBox_PasteEventHandler);
                }
                else
                {
                    textBox.PreviewTextInput -= TextBox_PreviewTextInput;
                    DataObject.RemovePastingHandler(textBox, TextBox_PasteEventHandler);
                }

                break;
            }

            case "DefaultValue":
            {
                var castedValue = (string) e.NewValue;

                if (castedValue != null)
                {
                    textBox.TextChanged += TextBox_TextChanged;
                }
                else
                {
                    textBox.TextChanged -= TextBox_TextChanged;
                }

                break;
            }
        }
    }

    #endregion

    private static void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        var textBox = (TextBox)sender;

        string newText;

        if (textBox.SelectionLength == 0)
        {
            newText = textBox.Text.Insert(textBox.SelectionStart, e.Text);
        }
        else
        {
            var textAfterDelete = textBox.Text.Remove(textBox.SelectionStart, textBox.SelectionLength);

            newText = textAfterDelete.Insert(textBox.SelectionStart, e.Text);
        }

        var evenOddConstraint = GetEvenOddConstraint(textBox);

        switch (GetOnlyNumeric(textBox))
        {
            case NumericFormat.Double:
            {
                if (double.TryParse(newText, out double number))
                {
                    switch (evenOddConstraint)
                    {
                        case EvenOddConstraint.OnlyEven:

                            if (number % 2 != 0)
                                e.Handled = true;
                            else
                                e.Handled = false;

                            break;

                        case EvenOddConstraint.OnlyOdd:

                            if (number % 2 == 0)
                                e.Handled = true;
                            else
                                e.Handled = false;

                            break;
                    }
                }
                else
                    e.Handled = true;

                break;
            }

            case NumericFormat.Int:
            {
                if (int.TryParse(newText, out int number))
                {
                    switch (evenOddConstraint)
                    {
                        case EvenOddConstraint.OnlyEven:

                            if (number % 2 != 0)
                                e.Handled = true;
                            else
                                e.Handled = false;

                            break;

                        case EvenOddConstraint.OnlyOdd:

                            if (number % 2 == 0)
                                e.Handled = true;
                            else
                                e.Handled = false;

                            break;
                    }
                }
                else
                    e.Handled = true;

                break;
            }

            case NumericFormat.Uint:
            {
                if (uint.TryParse(newText, out uint number))
                {
                    switch (evenOddConstraint)
                    {
                        case EvenOddConstraint.OnlyEven:

                            if (number % 2 != 0)
                                e.Handled = true;
                            else
                                e.Handled = false;

                            break;

                        case EvenOddConstraint.OnlyOdd:

                            if (number % 2 == 0)
                                e.Handled = true;
                            else
                                e.Handled = false;

                            break;
                    }
                }
                else
                    e.Handled = true;

                break;
            }

            case NumericFormat.Natural:
            {
                if (uint.TryParse(newText, out uint number))
                {
                    if (number == 0)
                        e.Handled = true;
                    else
                    {
                        switch (evenOddConstraint)
                        {
                            case EvenOddConstraint.OnlyEven:

                                if (number % 2 != 0)
                                    e.Handled = true;
                                else
                                    e.Handled = false;

                                break;

                            case EvenOddConstraint.OnlyOdd:

                                if (number % 2 == 0)
                                    e.Handled = true;
                                else
                                    e.Handled = false;

                                break;
                        }
                    }
                }
                else
                    e.Handled = true;

                break;
            }
        }
    }

    private static void TextBox_PasteEventHandler(object sender, DataObjectPastingEventArgs e)
    {
        var textBox = (TextBox)sender;

        if (e.DataObject.GetDataPresent(typeof(string)))
        {
            var clipboardText = (string) e.DataObject.GetData(typeof(string));

            var newText = textBox.Text.Insert(textBox.SelectionStart, clipboardText);

            var evenOddConstraint = GetEvenOddConstraint(textBox);

            switch (GetOnlyNumeric(textBox))
            {
                case NumericFormat.Double:
                {
                    if (double.TryParse(newText, out double number))
                    {
                        switch (evenOddConstraint)
                        {
                            case EvenOddConstraint.OnlyEven:

                                if (number % 2 != 0)
                                    e.CancelCommand();

                                break;

                            case EvenOddConstraint.OnlyOdd:

                                if (number % 2 == 0)
                                    e.CancelCommand();

                                break;
                        }
                    }
                    else
                        e.CancelCommand();

                    break;
                }

                case NumericFormat.Int:
                {
                    if (int.TryParse(newText, out int number))
                    {
                        switch (evenOddConstraint)
                        {
                            case EvenOddConstraint.OnlyEven:

                                if (number % 2 != 0)
                                    e.CancelCommand();

                                break;

                            case EvenOddConstraint.OnlyOdd:

                                if (number % 2 == 0)
                                    e.CancelCommand();


                                break;
                        }
                    }
                    else
                        e.CancelCommand();

                    break;
                }

                case NumericFormat.Uint:
                {
                    if (uint.TryParse(newText, out uint number))
                    {
                        switch (evenOddConstraint)
                        {
                            case EvenOddConstraint.OnlyEven:

                                if (number % 2 != 0)
                                    e.CancelCommand();

                                break;

                            case EvenOddConstraint.OnlyOdd:

                                if (number % 2 == 0)
                                    e.CancelCommand();


                                break;
                        }
                    }
                    else
                        e.CancelCommand();

                    break;
                }

                case NumericFormat.Natural:
                {
                    if (uint.TryParse(newText, out uint number))
                    {
                        if (number == 0)
                            e.CancelCommand();
                        else
                        {
                            switch (evenOddConstraint)
                            {
                                case EvenOddConstraint.OnlyEven:

                                    if (number % 2 != 0)
                                        e.CancelCommand();

                                    break;

                                case EvenOddConstraint.OnlyOdd:

                                    if (number % 2 == 0)
                                        e.CancelCommand();

                                    break;
                            }
                        }
                    }
                    else
                    {
                        e.CancelCommand();
                    }

                    break;
                }
            }
        }
        else
        {
            e.CancelCommand();
        }
    }

    private static void TextBox_TextChanged(object sender, TextChangedEventArgs e)
    {
        var textBox = (TextBox)sender;

        var defaultValue = GetDefaultValue(textBox);

        var evenOddConstraint = GetEvenOddConstraint(textBox);

        switch (GetOnlyNumeric(textBox))
        {
            case NumericFormat.Double:
            {
                if (double.TryParse(textBox.Text, out double number))
                {
                    switch (evenOddConstraint)
                    {
                        case EvenOddConstraint.OnlyEven:

                            if (number % 2 != 0)
                                textBox.Text = defaultValue;

                            break;

                        case EvenOddConstraint.OnlyOdd:

                            if (number % 2 == 0)
                                textBox.Text = defaultValue;

                            break;
                    }
                }
                else
                    textBox.Text = defaultValue;

                break;
            }

            case NumericFormat.Int:
            {
                if (int.TryParse(textBox.Text, out int number))
                {
                    switch (evenOddConstraint)
                    {
                        case EvenOddConstraint.OnlyEven:

                            if (number % 2 != 0)
                                textBox.Text = defaultValue;

                            break;

                        case EvenOddConstraint.OnlyOdd:

                            if (number % 2 == 0)
                                textBox.Text = defaultValue;

                            break;
                    }
                }
                else
                    textBox.Text = defaultValue;

                break;
            }

            case NumericFormat.Uint:
            {
                if (uint.TryParse(textBox.Text, out uint number))
                {
                    switch (evenOddConstraint)
                    {
                        case EvenOddConstraint.OnlyEven:

                            if (number % 2 != 0)
                                textBox.Text = defaultValue;

                            break;

                        case EvenOddConstraint.OnlyOdd:

                            if (number % 2 == 0)
                                textBox.Text = defaultValue;

                            break;
                    }
                }
                else
                    textBox.Text = defaultValue;

                break;
            }

            case NumericFormat.Natural:
            {
                if (uint.TryParse(textBox.Text, out uint number))
                {
                    if(number == 0)
                        textBox.Text = defaultValue;
                    else
                    {
                        switch (evenOddConstraint)
                        {
                            case EvenOddConstraint.OnlyEven:

                                if (number % 2 != 0)
                                    textBox.Text = defaultValue;

                                break;

                            case EvenOddConstraint.OnlyOdd:

                                if (number % 2 == 0)
                                    textBox.Text = defaultValue;

                                break;
                        }
                    }
                }
                else
                {
                    textBox.Text = defaultValue;
                }

                break;
            }
        }
    }
}

Und hier ist ein Beispiel für die einfache Verwendung:

<TextBox viewHelpers:TextBoxHelper.OnlyNumeric="Double"
         viewHelpers:TextBoxHelper.DefaultValue="1"/>

Oder

<TextBox viewHelpers:TextBoxHelper.OnlyNumeric="Natural"
         viewHelpers:TextBoxHelper.DefaultValue="3"
         viewHelpers:TextBoxHelper.EvenOddConstraint="OnlyOdd"/>

Beachten Sie, dass sich mein TextBoxHelper im Alias ​​viewHelpers xmlns befindet.

Ich hoffe, dass diese Implementierung die Arbeit anderer erleichtert :)

e.Handled = (int)e.Key >= 43 || (int)e.Key <= 34;

in der Vorschau Keydown-Ereignis des Textfelds.

PreviewTextInput += (s, e) =>
{
    e.Handled = !e.Text.All(char.IsDigit);
};

Wenn Sie nach einer schnellen und sehr einfachen Implementierung für diese Art von Problem suchen, bei der nur Ganzzahlen und Dezimalzahlen verwendet werden, fügen Sie in Ihrer XAML-Datei eine PreviewTextInputEigenschaft zu Ihrer hinzu TextBoxund verwenden Sie dann in Ihrer xaml.cs-Datei Folgendes:

private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    e.Handled = !char.IsDigit(e.Text.Last()) && !e.Text.Last() == '.';
}

Es ist überflüssig, jedes Mal die gesamte Zeichenfolge zu überprüfen, es sei denn, Sie haben, wie andere bereits erwähnt haben, etwas mit wissenschaftlicher Notation getan (wenn Sie jedoch bestimmte Zeichen wie 'e' hinzufügen, ist eine einfache Regex das Hinzufügen von Symbolen / Zeichen wirklich einfach und in anderen Antworten illustriert). Für einfache Gleitkommawerte reicht diese Lösung jedoch aus.

Geschrieben als Einzeiler mit Lambda-Ausdruck:

private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e) => e.Handled = !char.IsDigit(e.Text.Last() && !e.Text.Last() == '.');

Wir können eine Validierung für ein vom Textfeld geändertes Ereignis durchführen. Die folgende Implementierung verhindert andere Tastendruckeingaben als numerische und einen Dezimalpunkt.

private void textBoxNumeric_TextChanged(object sender, TextChangedEventArgs e) 
{         
      TextBox textBox = sender as TextBox;         
      Int32 selectionStart = textBox.SelectionStart;         
      Int32 selectionLength = textBox.SelectionLength;         
      String newText = String.Empty;         
      int count = 0;         
      foreach (Char c in textBox.Text.ToCharArray())         
      {             
         if (Char.IsDigit(c) || Char.IsControl(c) || (c == '.' && count == 0))             
         {                 
            newText += c;                 
            if (c == '.')                     
              count += 1;             
         }         
     }         
     textBox.Text = newText;         
     textBox.SelectionStart = selectionStart <= textBox.Text.Length ? selectionStart :        textBox.Text.Length;     
} 

Wie wäre es damit? Funktioniert gut für mich. Hoffe ich habe keine Edge Cases verpasst ...

MyTextBox.PreviewTextInput += (sender, args) =>
{
    if (!int.TryParse(args.Text, out _))
    {
        args.Handled = true;
    }
};

DataObject.AddPastingHandler(MyTextBox, (sender, args) =>
{
    var isUnicodeText = args.SourceDataObject.GetDataPresent(DataFormats.UnicodeText, true);
    if (!isUnicodeText)
    {
        args.CancelCommand();
    }

    var data = args.SourceDataObject.GetData(DataFormats.UnicodeText) as string;
    if (!int.TryParse(data, out _))
    {
        args.CancelCommand();
    }
});

In Windows Forms war es einfach; Sie können ein Ereignis für KeyPress hinzufügen und alles funktioniert problemlos. In WPF ist dieses Ereignis jedoch nicht vorhanden. Aber es gibt einen viel einfacheren Weg.

Die WPF TextBox hat das TextChanged-Ereignis, das für alles allgemein ist. Es beinhaltet das Einfügen, Tippen und alles, was Ihnen in den Sinn kommt.

Sie können also so etwas tun:

XAML:

<TextBox name="txtBox1" ... TextChanged="TextBox_TextChanged"/>

CODE HINTER:

private void TextBox_TextChanged(object sender, TextChangedEventArgs e) {
    string s = Regex.Replace(((TextBox)sender).Text, @"[^\d.]", "");
    ((TextBox)sender).Text = s;
}

Dies akzeptiert auch ., wenn Sie es nicht möchten, entfernen Sie es einfach aus der regexAnweisung zu sein @[^\d].

Hinweis : Dieses Ereignis kann in vielen Textfeldern verwendet werden, da es den senderText des Objekts verwendet. Sie schreiben das Ereignis nur einmal und können es für mehrere TextBoxen verwenden.

Jetzt weiß ich, dass diese Frage eine akzeptierte Antwort hat , aber ich persönlich finde sie etwas verwirrend und ich glaube, es sollte einfacher sein. Also werde ich versuchen zu demonstrieren, wie ich es so gut wie möglich zum Laufen gebracht habe:

In Windows Forms gibt es ein Ereignis namens, KeyPressdas für diese Art von Aufgabe perfekt geeignet ist. In WPF gibt es das jedoch nicht. Stattdessen verwenden wir das PreviewTextInputEreignis. Außerdem glaube ich, dass man für die Validierung eine verwenden kann, um die Bedingung foreachzu durchlaufen textbox.Textund zu überprüfen, ob sie übereinstimmt ;), aber ehrlich gesagt, dafür sind reguläre Ausdrücke gedacht.

Noch eine Sache, bevor wir in den heiligen Code eintauchen . Damit das Ereignis ausgelöst wird, kann man zwei Dinge tun:

1. Verwenden Sie XAML, um dem Programm mitzuteilen, welche Funktion aufgerufen werden soll: <PreviewTextInput="textBox_PreviewTextInput/>
2. Tun Sie dies im LoadedFalle des Formulars (in dem sich die Textbox befindet): textBox.PreviewTextInput += onlyNumeric;

Ich denke, die zweite Methode ist besser, weil Sie in solchen Situationen meistens dieselbe Bedingung ( regex) auf mehrere anwenden müssen TextBoxund sich nicht wiederholen möchten! .

Zum Schluss würden Sie Folgendes tun:

private void onlyNumeric(object sender, TextCompositionEventArgs e)
{
    string onlyNumeric = @"^([0-9]+(.[0-9]+)?)$";
    Regex regex = new Regex(onlyNumeric);
    e.Handled = !regex.IsMatch(e.Text);
}

Hier ist meine Version davon. Es basiert auf einer Basisklasse ValidatingTextBox, die nur rückgängig macht, was getan wurde, wenn es nicht "gültig" ist. Es unterstützt Einfügen, Ausschneiden, Löschen, Rücktaste, +, - usw.

Für 32-Bit-Ganzzahlen gibt es eine Int32TextBox-Klasse, die nur mit einer int verglichen wird. Ich habe auch Gleitkomma-Validierungsklassen hinzugefügt.

public class ValidatingTextBox : TextBox
{
    private bool _inEvents;
    private string _textBefore;
    private int _selectionStart;
    private int _selectionLength;

    public event EventHandler<ValidateTextEventArgs> ValidateText;

    protected override void OnPreviewKeyDown(KeyEventArgs e)
    {
        if (_inEvents)
            return;

        _selectionStart = SelectionStart;
        _selectionLength = SelectionLength;
        _textBefore = Text;
    }

    protected override void OnTextChanged(TextChangedEventArgs e)
    {
        if (_inEvents)
            return;

        _inEvents = true;
        var ev = new ValidateTextEventArgs(Text);
        OnValidateText(this, ev);
        if (ev.Cancel)
        {
            Text = _textBefore;
            SelectionStart = _selectionStart;
            SelectionLength = _selectionLength;
        }
        _inEvents = false;
    }

    protected virtual void OnValidateText(object sender, ValidateTextEventArgs e) => ValidateText?.Invoke(this, e);
}

public class ValidateTextEventArgs : CancelEventArgs
{
    public ValidateTextEventArgs(string text) => Text = text;

    public string Text { get; }
}

public class Int32TextBox : ValidatingTextBox
{
    protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !int.TryParse(e.Text, out var value);
}

public class Int64TextBox : ValidatingTextBox
{
    protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !long.TryParse(e.Text, out var value);
}

public class DoubleTextBox : ValidatingTextBox
{
    protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !double.TryParse(e.Text, out var value);
}

public class SingleTextBox : ValidatingTextBox
{
    protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !float.TryParse(e.Text, out var value);
}

public class DecimalTextBox : ValidatingTextBox
{
    protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !decimal.TryParse(e.Text, out var value);
}

Hinweis 1: Wenn Sie die WPF-Bindung verwenden, müssen Sie sicherstellen, dass Sie die Klasse verwenden, die zum gebundenen Eigenschaftstyp passt. Andernfalls kann dies zu seltsamen Ergebnissen führen.

Hinweis 2: Wenn Sie Gleitkommaklassen mit WPF-Bindung verwenden, stellen Sie sicher, dass die Bindung die aktuelle Kultur verwendet, um mit der von mir verwendeten TryParse-Methode übereinzustimmen.

Hier ist eine Bibliothek für die numerische Eingabe in WPF

Es hat Eigenschaften wie NumberStylesund RegexPatternzur Validierung.

Unterklassen WPF TextBox

Verwenden:

Private Sub DetailTextBox_PreviewTextInput( _
  ByVal sender As Object, _
  ByVal e As System.Windows.Input.TextCompositionEventArgs) _
  Handles DetailTextBox.PreviewTextInput

    If _IsANumber Then
        If Not Char.IsNumber(e.Text) Then
            e.Handled = True
        End If
    End If
End Sub

Ich habe mit einer ungebundenen Box für ein einfaches Projekt gearbeitet, an dem ich gearbeitet habe, daher konnte ich den Standardbindungsansatz nicht verwenden. Infolgedessen habe ich einen einfachen Hack erstellt, den andere möglicherweise sehr nützlich finden, indem sie einfach das vorhandene TextBox-Steuerelement erweitern:

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 Floating-Typ möchten Sie ihn natürlich als Float usw. analysieren. Es gelten die gleichen Grundsätze.

Dann müssen Sie in die XAML-Datei den relevanten Namespace aufnehmen:

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

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

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

Nachdem ich einige der Lösungen hier für einige Zeit verwendet hatte, entwickelte ich meine eigene, die für mein MVVM-Setup gut funktioniert. Beachten Sie, dass es nicht so dynamisch ist wie einige der anderen, da Benutzer weiterhin fehlerhafte Zeichen eingeben können, es sie jedoch daran hindert, die Taste zu drücken und somit etwas zu tun. Dies passt gut zu meinem Thema, Schaltflächen auszublenden, wenn Aktionen nicht ausgeführt werden können.

Ich habe eine, TextBoxdass ein Benutzer eine Anzahl von Dokumentseiten eingeben muss, um gedruckt zu werden:

<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 einen Knopf:

<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 gibt es die Methode von SetNumberOfPages(), aber es ist unwichtig für dieses Thema. In meinem Fall funktioniert dies gut, da ich der CodeBehind-Datei der Ansicht keinen Code hinzufügen muss und das Verhalten mithilfe der CommandEigenschaft steuern kann .

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

In der WPF-Anwendung können Sie dies behandeln, indem Sie das TextChangedEreignis behandeln:

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