Validierung in der textbox in WPF

Ich arbeite gerade an einer WPF-Anwendung, wo ich gerne ein TextBox können nur numerische Eingaben. Ich weiß, dass ich überprüfen kann, ob der Inhalt, wenn ich verloren den Fokus und die Inhalte sperren von numerischen, aber in anderen Windows Form-Anwendung, die wir benutzen, um völlig blockiert alle Eingaben, die von numerischen aufgeschrieben. Plus, die wir verwenden, um diesen code in einer separaten dll zu verweisen, an vielen stellen.

Hier ist der code, der im Jahr 2008 nicht mit WPF:

Public Shared Sub BloquerInt(ByRef e As System.Windows.Forms.KeyPressEventArgs, ByRef oTxt As Windows.Forms.TextBox, ByVal intlongueur As Integer)
    Dim intLongueurSelect As Integer = oTxt.SelectionLength
    Dim intPosCurseur As Integer = oTxt.SelectionStart
    Dim strValeurTxtBox As String = oTxt.Text.Substring(0, intPosCurseur) & oTxt.Text.Substring(intPosCurseur + intLongueurSelect, oTxt.Text.Length - intPosCurseur - intLongueurSelect)

    If IsNumeric(e.KeyChar) OrElse _
       Microsoft.VisualBasic.Asc(e.KeyChar) = System.Windows.Forms.Keys.Back Then
        If Microsoft.VisualBasic.AscW(e.KeyChar) = System.Windows.Forms.Keys.Back Then
            e.Handled = False
        ElseIf strValeurTxtBox.Length < intlongueur Then
            e.Handled = False
        Else
            e.Handled = True

        End If
    Else
        e.Handled = True
    End If

Gibt es eine entsprechende Möglichkeit in WPF? Ich hätte nichts dagegen, wenn dies in einem Stil, aber ich bin neu in WPF so Stil sind ein bisschen dunkel, was Sie können oder nicht tun können.

InformationsquelleAutor David Brunelle | 2009-08-28

Können Sie beschränken Sie die Eingabe auf nur zahlen mit einer angefügten Eigenschaft auf der TextBox. Definieren Sie die angefügte Eigenschaft einmal (auch in einer separaten dll) und verwenden Sie es auf ein beliebiges Textfeld. Hier ist die angefügte Eigenschaft:

   using System;
   using System.Windows;
   using System.Windows.Controls;
   using System.Windows.Input;

   ///<summary>
   ///Class that provides the TextBox attached property
   ///</summary>
   public static class TextBoxService
   {
      ///<summary>
      ///TextBox Attached Dependency Property
      ///</summary>
      public static readonly DependencyProperty IsNumericOnlyProperty = DependencyProperty.RegisterAttached(
         "IsNumericOnly",
         typeof(bool),
         typeof(TextBoxService),
         new UIPropertyMetadata(false, OnIsNumericOnlyChanged));

      ///<summary>
      ///Gets the IsNumericOnly property.  This dependency property indicates the text box only allows numeric or not.
      ///</summary>
      ///<param name="d"><see cref="DependencyObject"/> to get the property from</param>
      ///<returns>The value of the StatusBarContent property</returns>
      public static bool GetIsNumericOnly(DependencyObject d)
      {
         return (bool)d.GetValue(IsNumericOnlyProperty);
      }

      ///<summary>
      ///Sets the IsNumericOnly property.  This dependency property indicates the text box only allows numeric or not.
      ///</summary>
      ///<param name="d"><see cref="DependencyObject"/> to set the property on</param>
      ///<param name="value">value of the property</param>
      public static void SetIsNumericOnly(DependencyObject d, bool value)
      {
         d.SetValue(IsNumericOnlyProperty, value);
      }

      ///<summary>
      ///Handles changes to the IsNumericOnly property.
      ///</summary>
      ///<param name="d"><see cref="DependencyObject"/> that fired the event</param>
      ///<param name="e">A <see cref="DependencyPropertyChangedEventArgs"/> that contains the event data.</param>
      private static void OnIsNumericOnlyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
      {
         bool isNumericOnly = (bool)e.NewValue;

         TextBox textBox = (TextBox)d;

         if (isNumericOnly)
         {
            textBox.PreviewTextInput += BlockNonDigitCharacters;
            textBox.PreviewKeyDown += ReviewKeyDown;
         }
         else
         {
            textBox.PreviewTextInput -= BlockNonDigitCharacters;
            textBox.PreviewKeyDown -= ReviewKeyDown;
         }
      }

      ///<summary>
      ///Disallows non-digit character.
      ///</summary>
      ///<param name="sender">The source of the event.</param>
      ///<param name="e">An <see cref="TextCompositionEventArgs"/> that contains the event data.</param>
      private static void BlockNonDigitCharacters(object sender, TextCompositionEventArgs e)
      {
         foreach (char ch in e.Text)
         {
            if (!Char.IsDigit(ch))
            {
               e.Handled = true;
            }
         }
      }

      ///<summary>
      ///Disallows a space key.
      ///</summary>
      ///<param name="sender">The source of the event.</param>
      ///<param name="e">An <see cref="KeyEventArgs"/> that contains the event data.</param>
      private static void ReviewKeyDown(object sender, KeyEventArgs e)
      {
         if (e.Key == Key.Space)
         {
            //Disallow the space key, which doesn't raise a PreviewTextInput event.
            e.Handled = true;
         }
      }
   }

Hier ist, wie Sie es verwenden (ersetzen Sie "steuert" mit Ihrem eigenen Namensraum):

<TextBox controls:TextBoxService.IsNumericOnly="True" />

Ich werde versuchen, dass. Ich kann mir vorstellen, dass ich nahezu alles hinzufügen, wie, dass. Zum Beispiel, die maximale Länge der text im inneren, das ist auch ein weiteres problem, das ich hatte.
Habe vergessen zu erwähnen, es ist die max Länge eines schwimmenden Anzahl (maximale Anzahl der Dezimalstellen und die Anzahl der integer-Teil )
Ja, angefügte Eigenschaften sind sehr leistungsfähig und erlaubt Ihnen das hinzufügen alle Arten von Verhaltensweisen.
+1 - Sehr schön!
+1 meine erste angefügte Eigenschaften codiert, wie du gesagt hast! Danke!

InformationsquelleAutor John Myczek

Kann man sich die Validierung in Ihrer Bindung

<TextBox>
         <TextBox.Text>
              <Binding Path="CategoriaSeleccionada.ColorFondo"
                       UpdateSourceTrigger="PropertyChanged">
                     <Binding.ValidationRules>
                           <utilities:RGBValidationRule />
                     </Binding.ValidationRules>
               </Binding>
         </TextBox.Text>
</TextBox>

Blick auf dieses Beispiel (von meinem Programm), setzen Sie die überprüfung innerhalb der verbindlich wie diese. Mit UpdateSourceTrigger können Sie ändern, wenn Sie verbindlich aktualisiert wird (den Fokus verloren, in jedem ändern...)

Gut, die Validierung ist eine Klasse, werde ich Ihnen ein Beispiel:

class RGBValidationRule : ValidationRule
{
    public override ValidationResult Validate(object value, System.Globalization.CultureInfo cultureInfo)
    {
        //Here you make your validation using the value object.
        //If you want to check if the object is only numbers you can
        //Use some built-in method
        string blah = value.ToString();
        int num;
        bool isNum = int.TryParse(blah, out num);

        if (isNum) return new ValidationResult(true, null);
        else return new ValidationResult(false, "It's no a number");
    }
}

Kurz gesagt, die Arbeit zu tun im inneren, die Methode und geben Sie einen neuen ValidationResult. Der erste parameter ist ein boolescher Wert, der true ist, wenn die Validierung gut ist, false, wenn nicht. Der zweite parameter wird nur eine Nachricht für Informationen.

Ich denke, dass dies die Grundlagen des Textfeld-Validierung.

Hoffe, dass dies helfen.

EDIT: Sorry, ich weiß nicht, VB.NET aber ich denke, dass der C# code ist ziemlich einfach.

Ich kenne beide, so ist es für mich einfach zu conver. Danke, ich werde versuchen es bald genug.

InformationsquelleAutor Jesus Rodriguez

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.