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

Hinzufügen eines Vorschautext-Eingabeereignisses. Zum Beispiel so: <TextBox PreviewTextInput="PreviewTextInput" /> .

Innerhalb dieses Satzes wird dann die e.Handled wenn der Text nicht zulässig ist. e.Handled = !IsTextAllowed(e.Text);

Ich verwende eine einfache Regex in IsTextAllowed Methode, um zu sehen, ob ich zulassen soll, was sie eingegeben haben. In meinem Fall möchte ich nur Zahlen, Punkte und Bindestriche 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 verhindern wollen, dass falsche Daten eingefügt werden, schließen Sie den DataObject.Pasting Veranstaltung DataObject.Pasting="TextBoxPasting" wie gezeigt aquí (Auszug aus dem Code):

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

Answer 2

Der Ereignishandler zeigt eine Vorschau der Texteingabe an. Hier passt ein regulärer Ausdruck nur auf die Texteingabe, wenn es sich nicht um eine Zahl handelt, und dann wird sie nicht in das Textfeld eingegeben.

Wenn Sie nur Buchstaben wollen, ersetzen Sie den regulären Ausdruck durch [^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);
}

Answer 3

Ich habe etwas von dem, was bereits hier war und setzen meine eigene Wendung auf es mit einem Verhalten, so dass ich nicht haben, um diesen Code in eine Tonne von Ansichten zu propagieren ...

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 entsprechende 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>

Answer 4

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

• Verbessertes Verhalten bei Del y Rücktaste Tasten
• Hinzugefügt EmptyValue Eigenschaft, wenn leere Zeichenfolge unangemessen ist

• Einige kleinere Tippfehler korrigiert

  /// <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>

Answer 5

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

Binden Sie Ihre textBox mit einem Integer-Eigenschaft in der Ansicht Modell, und dies wird wie ein Juwel arbeiten ... es wird sogar zeigen, Validierung, 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();
    }
}