WPF TextBox pour saisir des valeurs décimales
Existe-t-il un moyen décent d'obtenir un contrôle WPF lié à une valeur decimal?
Lorsque je lie simplement le TextBox ou DataGridTextColumn à un decimal, la saisie de données est un problème.
<TextBox Text="{Binding MyDecimal, UpdateSourceTrigger=PropertyChanged,
ValidatesOnDataErrors=True}"/>
Quand j'essaye d'entrer "0,5" dans ce TextBox j'obtiendrai "5" en conséquence. Il est presque impossible de saisir "0,5" (à part entrer 1,5 et remplacer le "1" par un "0").
Lorsque j'utilise StringFormat, la saisie des données n'est que légèrement améliorée:
<TextBox Text="{Binding MyDecimal, StringFormat=F1, UpdateSourceTrigger=PropertyChanged,
ValidatesOnDataErrors=True}"/>
Maintenant, quand j'essaye d'entrer "0,5", je vais finir avec "0,5,0", ce qui est toujours faux mais au moins je peux supprimer le "0" de fin sans trop de difficulté.
Pourtant, entrer des types decimal à l'aide de WPF est très gênant, car ces TextBoxes sont très sujets à des erreurs de saisie de données, ce qui est vraiment pénible surtout pour les valeurs!
Alors, que suis-je censé utiliser pour la saisie de données décimales dans WPF? Ou Microsoft ne prend-il pas en charge les données décimales?
J'utilise actuellement ce comportement pour l'entrée numérique et décimale:
public class TextBoxInputBehavior : Behavior<TextBox>
{
const NumberStyles validNumberStyles = NumberStyles.AllowDecimalPoint |
NumberStyles.AllowThousands |
NumberStyles.AllowLeadingSign;
public TextBoxInputBehavior()
{
this.InputMode = TextBoxInputMode.None;
this.JustPositivDecimalInput = false;
}
public TextBoxInputMode InputMode { get; set; }
public static readonly DependencyProperty JustPositivDecimalInputProperty =
DependencyProperty.Register("JustPositivDecimalInput", typeof(bool),
typeof(TextBoxInputBehavior), new FrameworkPropertyMetadata(false));
public bool JustPositivDecimalInput
{
get { return (bool)GetValue(JustPositivDecimalInputProperty); }
set { SetValue(JustPositivDecimalInputProperty, value); }
}
protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.PreviewTextInput += AssociatedObjectPreviewTextInput;
AssociatedObject.PreviewKeyDown += AssociatedObjectPreviewKeyDown;
DataObject.AddPastingHandler(AssociatedObject, Pasting);
}
protected override void OnDetaching()
{
base.OnDetaching();
AssociatedObject.PreviewTextInput -= AssociatedObjectPreviewTextInput;
AssociatedObject.PreviewKeyDown -= AssociatedObjectPreviewKeyDown;
DataObject.RemovePastingHandler(AssociatedObject, Pasting);
}
private void Pasting(object sender, DataObjectPastingEventArgs e)
{
if (e.DataObject.GetDataPresent(typeof(string)))
{
var pastedText = (string)e.DataObject.GetData(typeof(string));
if (!this.IsValidInput(this.GetText(pastedText)))
{
System.Media.SystemSounds.Beep.Play();
e.CancelCommand();
}
}
else
{
System.Media.SystemSounds.Beep.Play();
e.CancelCommand();
}
}
private void AssociatedObjectPreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Space)
{
if (!this.IsValidInput(this.GetText(" ")))
{
System.Media.SystemSounds.Beep.Play();
e.Handled = true;
}
}
}
private void AssociatedObjectPreviewTextInput(object sender, TextCompositionEventArgs e)
{
if (!this.IsValidInput(this.GetText(e.Text)))
{
System.Media.SystemSounds.Beep.Play();
e.Handled = true;
}
}
private string GetText(string input)
{
var txt = this.AssociatedObject;
int selectionStart = txt.SelectionStart;
if (txt.Text.Length < selectionStart)
selectionStart = txt.Text.Length;
int selectionLength = txt.SelectionLength;
if (txt.Text.Length < selectionStart + selectionLength)
selectionLength = txt.Text.Length - selectionStart;
var realtext = txt.Text.Remove(selectionStart, selectionLength);
int caretIndex = txt.CaretIndex;
if (realtext.Length < caretIndex)
caretIndex = realtext.Length;
var newtext = realtext.Insert(caretIndex, input);
return newtext;
}
private bool IsValidInput(string input)
{
switch (InputMode)
{
case TextBoxInputMode.None:
return true;
case TextBoxInputMode.DigitInput:
return CheckIsDigit(input);
case TextBoxInputMode.DecimalInput:
decimal d;
//wen mehr als ein Komma
if (input.ToCharArray().Where(x => x == ',').Count() > 1)
return false;
if (input.Contains("-"))
{
if (this.JustPositivDecimalInput)
return false;
if (input.IndexOf("-",StringComparison.Ordinal) > 0)
return false;
if(input.ToCharArray().Count(x=>x=='-') > 1)
return false;
//minus einmal am anfang zulässig
if (input.Length == 1)
return true;
}
var result = decimal.TryParse(input, validNumberStyles, CultureInfo.CurrentCulture, out d);
return result;
default: throw new ArgumentException("Unknown TextBoxInputMode");
}
return true;
}
private bool CheckIsDigit(string wert)
{
return wert.ToCharArray().All(Char.IsDigit);
}
}
public enum TextBoxInputMode
{
None,
DecimalInput,
DigitInput
}
L'utilisation de XAML ressemble à ceci:
<TextBox Text="{Binding Sum}">
<i:Interaction.Behaviors>
<Behaviors:TextBoxInputBehavior InputMode="DecimalInput"/>
</i:Interaction.Behaviors>
</TextBox>
private void DecimalTextBox_PreviewTextInput(object sender, System.Windows.Input.TextCompositionEventArgs e)
{
bool approvedDecimalPoint = false;
if (e.Text == ".")
{
if (!((TextBox)sender).Text.Contains("."))
approvedDecimalPoint = true;
}
if (!(char.IsDigit(e.Text, e.Text.Length - 1) || approvedDecimalPoint))
e.Handled = true;
}
WPF Extended toolkit possède un contrôle DecimalUpDown qui peut répondre à vos besoins. Son utilisation est gratuite et il vaut mieux l'utiliser que d'essayer de lancer la vôtre.
En ce qui concerne la validation de l'entrée, il existe un certain nombre de façons d'appliquer la validation, en voici une détaillée dans MSDN. I détaillez une autre approche pour la validation de liaison personnalisée dans deux articles de mon blog (vous appliqueriez la validation à la liaison de propriété Value sur le contrôle DecimalUpDown).
J'ai également rencontré ce problème; avec UpdateSourceTrigger=PropertyChanged il semble que la liaison essaie de mettre à jour le texte pendant que vous le tapez. Pour résoudre ce problème, nous avons modifié nos champs de saisie afin que UpdateSourceTrigger=LostFocus, par exemple.:
<TextBox Text="{Binding MyDecimal, UpdateSourceTrigger=LostFocus, ValidatesOnDataErrors=True, StringFormat=n1}" />
Vous pouvez définir vos propres erreurs de validation en utilisant l'interface IDataErrorInfo. Il vous suffit d'ajouter les éléments suivants à votre modèle de support:
public class MyModel : IDataErrorInfo
{
/* my properties */
public string Error { get { return null; } }
public string this[string name]
{
get
{
switch (name)
{
case "MyDecimal":
return NumberHelper.IsValidValue(MyDecimal) ? message : null;
default: return null;
}
}
}
private string message = "Invalid value";
}
J'ai implémenté ma propre TextBox. Il met à jour la source, quand il y a un nombre dans le texte, sinon non. Sur Focus perdu, j'ai lu la propriété source. Tout ce que vous avez à faire est de remplacer le TextBox par cette classe et de lier la propriété "Number" qui est de type double.
public class DoubleTextBox: TextBox
{
public DoubleTextBox()
{
TextChanged += DoubleTextBox_TextChanged;
LostFocus += DoubleTextBox_LostFocus;
}
void DoubleTextBox_LostFocus(object sender, System.Windows.RoutedEventArgs e)
{
Text = Number.ToString("N2");
}
void DoubleTextBox_TextChanged(object sender, TextChangedEventArgs e)
{
double zahl;
if (string.IsNullOrWhiteSpace(Text))
{
Number = 0;
}
else if (double.TryParse(Text, out zahl))
{
Number = Double.Parse(zahl.ToString("N2"));
}
else
{
ValidationError validationError =
new ValidationError(new ExceptionValidationRule(), GetBindingExpression(NumberProperty));
validationError.ErrorContent = "Keine gültige Zahl";
Validation.MarkInvalid(
GetBindingExpression(NumberProperty),
validationError);
}
}
public double Number
{
get { return (double)this.GetValue(NumberProperty); }
set { this.SetValue(NumberProperty, value); }
}
public static readonly DependencyProperty NumberProperty = DependencyProperty.Register(
"Number", typeof(double), typeof(DoubleTextBox),
new FrameworkPropertyMetadata
(
0d,
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault
)
);
}
Je sais que ce message est ancien, mais il vient en premier sur la recherche Google pour ce problème. Comme j'ai eu une erreur avec le package system.windows.interactivity (ancienne version de ce package), j'ai poursuivi ma recherche.
Ce message sur MSDN a résolu mon problème et c'est une solution d'une seule ligne juste avant d'initialiser le composant sur la fenêtre principale comme ceci:
Public Sub New()
' This call is required by the designer.
FrameworkCompatibilityPreferences.KeepTextBoxDisplaySynchronizedWithTextProperty = False
InitializeComponent()
' Add any initialization after the InitializeComponent() call.
End Sub
J'espère que cela aidera d'autres chercheurs de Google.
Cela ne permettra d'entrer que des décimales dans la zone de texte et rien d'autre.
Le viewmodel ressemble à ceci:
private string _decimalVal = "0";
public string decimalVal
{
get { return _decimalVal.ToString(); }
set
{
if (string.IsNullOrEmpty(value) || value == "-")
SetProperty(ref _decimalVal, value);
else if (Decimal.TryParse(value, out decimal newVal))
{
if (newVal == 0)
value = "0";
SetProperty(ref _decimalVal, value = (value.Contains(".")) ? Convert.ToDecimal(value).ToString("0.00") : value);
}
}
}
L'utilisation de XAML ressemble à ceci:
<TextBox Text="{Binding decimalVal,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" />
Je suis nouveau, donc je ne peux pas commenter sa réponse, mais j'ai corrigé les problèmes de nombre négatif dans le code de blindmeis.
Modifiez simplement le
if (input.Contains("-"))
section de IsValidInput () à ...
if (input.Contains("-"))
{
if (this.JustPositivDecimalInput)
return false;
//minus einmal am anfang zulässig
//minus once at the beginning
if (input.IndexOf("-", StringComparison.Ordinal) == 0 && input.ToCharArray().Count(x => x == '-') == 1)
{
if(input.Length == 1)
{
//INPUT IS "-"
return true;
}
else if (input.Length == 2)
{
//VALIDATE NEGATIVE DECIMALS...INPUT IS "-."
if (input.IndexOf(".", StringComparison.Ordinal) == 1)
{
return true;
}
}
else
{
return decimal.TryParse(input, validNumberStyles, CultureInfo.CurrentCulture, out d);
}
}
}
si vous souhaitez que la zone de texte n'autorise que les décimales, écrivez l'événement previewinputtext pour cette zone de texte. puis dans ce cas, écrivez ce code
decimal result;
e.Handled=!decimal.TryParse((sender as TextBox).Text + e.Text, out result)
Ce regex fonctionne
private void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
Regex regex = new Regex("^[.][0-9]+$|^[0-9]*[.]{0,1}[0-9]*$");
e.Handled = !regex.IsMatch((sender as TextBox).Text.Insert((sender as TextBox).SelectionStart,e.Text));
}