Comment faire en sorte qu'une TextBox n'accepte que les entrées numériques dans WPF?
Je cherche à accepter les chiffres et le point décimal, mais pas de signe.
J'ai consulté des exemples utilisant le contrôle NumericUpDown pour Windows Forms et cet exemple de contrôle personnalisé NumericUpDown de Microsoft . Mais jusqu'à présent, il semble que NumericUpDown (pris en charge par WPF ou non) ne fournira pas les fonctionnalités souhaitées. De la manière dont mon application est conçue, personne qui a l’esprit juste ne voudra jouer avec les flèches. Cela n’a aucun sens pratique, dans le contexte de ma candidature.
Je cherche donc un moyen simple de faire en sorte qu'une TextBox WPF standard n'accepte que les caractères souhaités. Est-ce possible? Est-ce pratique?
Ajoutez un événement de saisie de texte en aperçu. Comme si: <TextBox PreviewTextInput="PreviewTextInput" />.
Ensuite, à l'intérieur de cet ensemble, le e.Handled si le texte n'est pas autorisé. e.Handled = !IsTextAllowed(e.Text);
J'utilise une expression rationnelle simple dans la méthode IsTextAllowed pour voir si je devrais autoriser ce qu'ils ont tapé. Dans mon cas, je veux seulement autoriser les nombres, les points et les tirets.
private static readonly Regex _regex = new Regex("[^0-9.-]+"); //regex that matches disallowed text
private static bool IsTextAllowed(string text)
{
return !_regex.IsMatch(text);
}
Si vous souhaitez empêcher le collage de données incorrectes, raccordez l'événement DataObject.Pasting _ DataObject.Pasting="TextBoxPasting" comme indiqué ici (extrait du 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();
}
}
Le gestionnaire d'événements est en train de prévisualiser la saisie de texte. Ici, une expression régulière ne correspond à la saisie de texte que s'il ne s'agit pas d'un nombre, puis ne s'applique pas à la zone de saisie.
Si vous ne voulez que des lettres, remplacez l'expression régulière par [^a-zA-Z].
XAML
<TextBox Name="NumberTextBox" PreviewTextInput="NumberValidationTextBox"/>
FICHIER XAML.CS
using System.Text.RegularExpressions;
private void NumberValidationTextBox(object sender, TextCompositionEventArgs e)
{
Regex regex = new Regex("[^0-9]+");
e.Handled = regex.IsMatch(e.Text);
}
J'ai utilisé une partie de ce qui était déjà là et y ai mis mon propre comportement en évitant de propager ce code à travers une tonne de vues ...
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;
}
}
}
Voici le code de vue pertinent:
<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>
Ceci est une solution améliorée de WilP s. Mes améliorations sont:
- Amélioration du comportement des boutons Del et Backspace
- Ajout de la propriété
EmptyValue, si la chaîne vide est inappropriée - Correction de quelques fautes de frappe mineures
/// <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] --------------------------------
}
L'utilisation est assez simple:
<i:Interaction.Behaviors>
<behaviours:TextBoxInputRegExBehaviour RegularExpression="^\d+$" MaxLength="9" EmptyValue="0" />
</i:Interaction.Behaviors>
Ajoutez une RÈGLE DE VALIDATION afin que, lorsque le texte change, vérifiez si les données sont numériques et, si c'est le cas, autorise la poursuite du traitement. Si ce n'est pas le cas, informe l'utilisateur que seules les données numériques sont acceptées dans ce champ.
En savoir plus dans Validation dans Windows Presentation Foundation
Voici un moyen très simple et facile de faire cela en utilisant MVVM.
Liez votre textBox à une propriété d'entier dans le modèle de vue, et cela fonctionnera comme une gemme ... il montrera même la validation lorsqu'un non-entier est entré dans la zone de texte.
Code XAML:
<TextBox x:Name="contactNoTxtBox" Text="{Binding contactNo}" />
Voir le code du modèle:
private long _contactNo;
public long contactNo
{
get { return _contactNo; }
set
{
if (value == _contactNo)
return;
_contactNo = value;
OnPropertyChanged();
}
}
Pourrait aussi simplement implémenter une règle de validation et l'appliquer à la zone de texte:
<TextBox>
<TextBox.Text>
<Binding Path="OnyDigitInput" Mode="TwoWay" UpdateSourceTrigger="PropertyChanged">
<Binding.ValidationRules>
<conv:OnlyDigitsValidationRule />
</Binding.ValidationRules>
</Binding>
</TextBox.Text>
Avec l’application de la règle suivante (en utilisant la même expression rationnelle que celle proposée dans d’autres réponses):
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;
}
}
Ici, j'ai une solution simple inspirée par la réponse de Ray . Cela devrait être suffisant pour identifier toute forme de numéro.
Cette solution peut également être facilement modifiée si vous souhaitez uniquement des nombres positifs, des valeurs entières ou des valeurs précises avec un nombre maximal de décimales, etc.
Comme suggéré dans La réponse de Ray , vous devez d'abord ajouter un événement PreviewTextInput:
<TextBox PreviewTextInput="TextBox_OnPreviewTextInput"/>
Ensuite, mettez ce qui suit dans le code derrière:
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);
}
J'ai autorisé les numéros du clavier numérique et le retour arrière:
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);
}
Je supposerai que:
Votre propriété TextBox pour laquelle vous souhaitez autoriser la saisie numérique uniquement a initialement sa propriété Text définie sur une valeur numérique valide (par exemple, 2.7172).
Votre Textbox est un enfant de votre fenêtre principale
Votre fenêtre principale est de classe Window1
Votre nom TextBox est numericTB
Idée basique:
Ajoutez:
private string previousText;à votre classe de fenêtre principale (Window1)Ajoutez:
previousText = numericTB.Text;à votre constructeur de fenêtre principaleCréez un gestionnaire pour l'événement numericTB.TextChanged afin qu'il ressemble à ceci:
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; }
Ceci conservera numeroTB.Text avec previousText tant qu'il est valide, et définira numericTB.Text sur sa dernière valeur valide si l'utilisateur écrit quelque chose que vous n'aimez pas. Bien sûr, ceci n’est qu’une idée de base, et c’est juste «résistant aux idiots», pas «à l’abri». Il ne gère pas le cas dans lequel l'utilisateur décoiffe des espaces, par exemple. Voici donc une solution complète qui, à mon avis, est "idiote", et si je me trompe, dites-moi:
Contenu de votre fichier Window1.xaml:
<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>Contenu de votre fichier Window.xaml.cs:
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; } } } } }
Et c'est tout. Si vous avez plusieurs TextBox, je vous recommande de créer un CustomControl héritant de TextBox afin de pouvoir envelopper les propriétés previousText et numericTB_TextChanged dans un fichier séparé.
Si vous ne voulez pas écrire beaucoup de code pour faire une fonction de base (je ne sais pas pourquoi les gens font de longues méthodes), vous pouvez simplement faire ceci:
Ajouter un espace de nom:
using System.Text.RegularExpressions;En XAML, définissez une propriété TextChanged:
<TextBox x:Name="txt1" TextChanged="txt1_TextChanged"/>Dans WPF sous la méthode txt1_TextChanged, ajoutez
Regex.Replace:private void txt1_TextChanged(object sender, TextChangedEventArgs e) { txt1.Text = Regex.Replace(txt1.Text, "[^0-9]+", ""); }
C'est le seul code nécessaire:
void MyTextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = new Regex("[^0-9]+").IsMatch(e.Text);
}
Cela permet uniquement de saisir des nombres dans la zone de texte.
Pour autoriser un signe décimal ou un signe moins, vous pouvez modifier l'expression régulière en [^0-9.-]+.
PreviewTextInput += (s, e) =>
{
e.Handled = !e.Text.All(char.IsDigit);
};
e.Handled = (int)e.Key >= 43 || (int)e.Key <= 34;
dans l'aperçu de l'événement keydown de la zone de texte.
Nous pouvons effectuer une validation sur l'événement de zone de texte modifié. L’implémentation suivante empêche la saisie au clavier autre que numérique et un point décimal.
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;
}
Une autre approche consiste à utiliser un comportement attaché. J'ai implémenté ma classe personnalisée TextBoxHelper, qui peut être utilisée dans les zones de texte de tout mon projet. Parce que j’ai pensé que s’abonner aux événements de chaque zone de texte et de chaque fichier XAML individuel à cette fin pouvait prendre beaucoup de temps.
La classe TextBoxHelper que j'ai implémentée présente les caractéristiques suivantes:
- Filtrer et accepter uniquement les nombres au format Double, Int, Uint et Natural
- Filtrer et accepter uniquement les nombres Pair ou Odd
- Gestion du gestionnaire d'événement de collage pour empêcher le collage de texte non valide dans nos champs de texte numériques
- Peut définir une valeur par défaut qui sera utilisée pour éviter que des données non valides ne constituent le dernier coup en s'abonnant à l'événement TextChanged de la zone de texte
Voici l'implémentation de la classe TextBoxHelper:
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;
}
}
}
}
Et voici quelques exemples de son utilisation facile:
<TextBox viewHelpers:TextBoxHelper.OnlyNumeric="Double"
viewHelpers:TextBoxHelper.DefaultValue="1"/>
Ou
<TextBox viewHelpers:TextBoxHelper.OnlyNumeric="Natural"
viewHelpers:TextBoxHelper.DefaultValue="3"
viewHelpers:TextBoxHelper.EvenOddConstraint="OnlyOdd"/>
Notez que mon TextBoxHelper réside dans l'alias viewHelpers xmlns.
J'espère que cette implémentation facilitera le travail de quelqu'un d'autre :)
Dans Windows Forms, c'était facile. vous pouvez ajouter un événement pour KeyPress et tout fonctionne facilement. Cependant, dans WPF, cet événement n’est pas là. Mais il existe un moyen beaucoup plus simple pour cela.
Le WPF TextBox a l'événement TextChanged qui est général pour tout. Cela inclut le collage, la dactylographie et tout ce qui peut vous venir à l’esprit.
Donc, vous pouvez faire quelque chose comme ça:
XAML:
<TextBox name="txtBox1" ... TextChanged="TextBox_TextChanged"/>
CODE DERRIÈRE:
private void TextBox_TextChanged(object sender, TextChangedEventArgs e) {
string s = Regex.Replace(((TextBox)sender).Text, @"[^\d.]", "");
((TextBox)sender).Text = s;
}
Cela accepte également .; si vous ne le souhaitez pas, supprimez-le simplement de l'instruction regex pour qu'il soit @[^\d].
Note : Cet événement peut être utilisé sur de nombreux TextBox car il utilise le texte de l'objet sender. Vous écrivez l'événement une seule fois et pouvez l'utiliser pour plusieurs TextBox.
Pour ceux qui recherchent une implémentation rapide et très simple pour ce type de problème utilisant uniquement des entiers et des décimales, dans votre fichier XAML, ajoutez une propriété PreviewTextInput à votre TextBoxet ensuite dans votre fichier xaml.cs:
private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = !char.IsDigit(e.Text.Last()) && !e.Text.Last() == '.';
}
Il est en quelque sorte redondant de vérifier toute la chaîne à chaque fois que, comme d'autres l'ont mentionné, vous utilisez quelque chose avec la notation scientifique (bien que, si vous ajoutez certains caractères tels que 'e', une regex simple ajoutant des symboles/caractères est très simple et illustré dans d’autres réponses). Mais pour les valeurs à virgule flottante simples, cette solution suffira.
Écrit comme une ligne avec une expression lambda:
private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e) => e.Handled = !char.IsDigit(e.Text.Last() && !e.Text.Last() == '.');
Maintenant, je sais que cette question a une réponse acceptée , mais personnellement, je trouve cela un peu déroutant et je pense que cela devrait être plus facile que cela. Je vais donc essayer de démontrer comment je l’ai obtenu au mieux:
Dans Windows Forms, il existe un événement appelé KeyPress qui convient parfaitement à ce type de tâche. Mais cela n’existe pas dans WPF, nous allons donc utiliser l’événement PreviewTextInput. De plus, pour la validation, je pense que l’on peut utiliser un foreach pour parcourir le textbox.Text et vérifier s’il correspond à;) la condition, mais honnêtement, c’est pour cela que expressions régulières sont.
Encore une chose avant de plonger dans le code sacré. Pour que l'événement soit déclenché, on peut faire deux choses:
- Utilisez XAML pour indiquer au programme la fonction à appeler:
<PreviewTextInput="textBox_PreviewTextInput/> - Faites-le dans l'événement
Loadeddu formulaire (dans lequel se trouve la zone de texte):textBox.PreviewTextInput += onlyNumeric;
Je pense que la deuxième méthode est meilleure car dans de telles situations, vous devrez généralement appliquer la même condition (regex) à plus d'une TextBox et vous ne voulez pas vous répéter! .
Enfin, voici comment vous le feriez:
private void onlyNumeric(object sender, TextCompositionEventArgs e)
{
string onlyNumeric = @"^([0-9]+(.[0-9]+)?)$";
Regex regex = new Regex(onlyNumeric);
e.Handled = !regex.IsMatch(e.Text);
}
Lors de la vérification d'une valeur numérique, vous pouvez utiliser la fonction VisualBasic.IsNumeric .
Voici une bibliothèque pour la saisie numérique en WPF
Il possède des propriétés telles que NumberStyles et RegexPattern pour la validation.
Sous-classes WPF TextBox
Je travaillais avec une boîte non liée pour un projet simple sur lequel je travaillais, je ne pouvais donc pas utiliser l'approche de reliure standard. En conséquence, j'ai créé un hack simple que d'autres pourraient trouver très utile en étendant simplement le contrôle TextBox existant:
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;
}
}
}
}
Évidemment, pour un type flottant, vous voudrez l’analyser comme un flottant, etc. Les mêmes principes s'appliquent.
Ensuite, dans le fichier XAML, vous devez inclure l'espace de noms approprié:
<UserControl x:Class="MyApplication.UserControls.UnParameterisedControl"
[ Snip ]
xmlns:interfaceSupport="clr-namespace:MyApplication.InterfaceSupport"
>
Après cela, vous pouvez l'utiliser comme contrôle régulier:
<interfaceSupport:NumericTextBox Height="23" HorizontalAlignment="Left" Margin="168,51,0,0" x:Name="NumericBox" VerticalAlignment="Top" Width="120" >
Après avoir utilisé certaines des solutions ici pendant un certain temps, j'ai développé la mienne qui fonctionne bien pour ma configuration MVVM. Notez que ce n'est pas aussi dynamique que certains autres dans le sens de permettre toujours aux utilisateurs de saisir des caractères erronés, mais cela les empêche d'appuyer sur le bouton et donc de ne rien faire. Cela va bien avec mon thème de grisonner les boutons lorsque des actions ne peuvent pas être effectuées.
J'ai une TextBox qu'un utilisateur doit entrer un nombre de pages de document à imprimer:
<TextBox Text="{Binding NumberPagesToPrint, UpdateSourceTrigger=PropertyChanged}"/>
... avec cette propriété de liaison:
private string _numberPagesToPrint;
public string NumberPagesToPrint
{
get { return _numberPagesToPrint; }
set
{
if (_numberPagesToPrint == value)
{
return;
}
_numberPagesToPrint = value;
OnPropertyChanged("NumberPagesToPrint");
}
}
J'ai aussi un bouton:
<Button Template="{DynamicResource CustomButton_Flat}" Content="Set"
Command="{Binding SetNumberPagesCommand}"/>
... avec cette liaison de commande:
private RelayCommand _setNumberPagesCommand;
public ICommand SetNumberPagesCommand
{
get
{
if (_setNumberPagesCommand == null)
{
int num;
_setNumberPagesCommand = new RelayCommand(param => SetNumberOfPages(),
() => Int32.TryParse(NumberPagesToPrint, out num));
}
return _setNumberPagesCommand;
}
}
Et puis il y a la méthode de SetNumberOfPages(), mais c'est sans importance pour ce sujet. Cela fonctionne bien dans mon cas, car je n'ai pas besoin d'ajouter de code dans le fichier code-behind de View et cela me permet de contrôler le comportement à l'aide de la propriété Command.
Dans l'application WPF, vous pouvez gérer cela en gérant l'événement TextChanged:
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;
}
}
Voici ma version de celui-ci. Elle est basée sur une classe ValidatingTextBox de base qui annule simplement ce qui a été fait si ce n’est pas "valide". Il supporte coller, couper, supprimer, retour arrière, +, - etc.
Pour l'entier 32 bits, il existe une classe Int32TextBox qui se compare simplement à un int. J'ai également ajouté des classes de validation en virgule flottante.
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);
}
Remarque 1: Lorsque vous utilisez la liaison WPF, vous devez vous assurer que vous utilisez la classe qui correspond au type de propriété liée, sinon vous risquez d'obtenir des résultats étranges.
Remarque 2: Lorsque vous utilisez des classes à virgule flottante avec une liaison WPF, assurez-vous que la liaison utilise la culture actuelle pour correspondre à la méthode TryParse que j'ai utilisée.
Que dis-tu de ça? Fonctionne bien pour moi. J'espère que je n'ai raté aucun cas Edge ...
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();
}
});
Pour les développeurs qui souhaitent que leurs champs de texte acceptent uniquement les nombres non signés, tels que les ports de socket, etc.:
WPF
<TextBox PreviewTextInput="Port_PreviewTextInput" MaxLines="1"/>
C #
private void Port_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = !int.TryParse(e.Text, out int x);
}
Utilisation:
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
Voici ce que je voudrais utiliser pour obtenir une zone de texte WPF acceptant les chiffres et la virgule décimale:
class numericTextBox : TextBox
{
protected override void OnKeyDown(KeyEventArgs e)
{
bool b = false;
switch (e.Key)
{
case Key.Back: b = true; break;
case Key.D0: b = true; break;
case Key.D1: b = true; break;
case Key.D2: b = true; break;
case Key.D3: b = true; break;
case Key.D4: b = true; break;
case Key.D5: b = true; break;
case Key.D6: b = true; break;
case Key.D7: b = true; break;
case Key.D8: b = true; break;
case Key.D9: b = true; break;
case Key.OemPeriod: b = true; break;
}
if (b == false)
{
e.Handled = true;
}
base.OnKeyDown(e);
}
}
Mettez le code dans un nouveau fichier de classe, ajoutez
using System.Windows.Controls;
using System.Windows.Input;
en haut du fichier et créez la solution. Le contrôle numericTextBox apparaîtra alors en haut de la boîte à outils.