entrée de texte au format de chaîne personnalisée wpf

Pour empêcher les utilisateurs d'entrer autre chose que des nombres, vous devez utiliser l'événement PrevieTextInput, il est logique de créer un contrôle personnalisé pour cela. Les quelques lignes ci-dessous empêcheront l'utilisateur de saisir autre chose que des chiffres

    <Grid>            
        <TextBox Text="{Binding Text}" PreviewTextInput="TextBox_PreviewTextInput"/>
        <TextBlock HorizontalAlignment="Right" Margin="5,0">g</TextBlock>
    </Grid>


    private void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        var tb = sender as TextBox;
        e.Handled = !double.TryParse(tb.Text+e.Text, out double d);
    }

P.S. si vous n'aimez pas l'utilisation de try Catch, vous pouvez utiliser une expression régulière pour cela

Vous devez en fait gérer trois événements:

• PreviewTextInput
• PreviewKeyDown - pour empêcher la saisie de caractères d'espacement, car ils ne sont pas gérés par PreviewTextInput
• DataObject.Pasting événement joint pour empêcher l'utilisateur de coller du texte non valide à partir du presse-papiers

Il vaut mieux encapsuler cette logique dans un comportement. A ont des exemples de comportements similaires: TextBoxIntegerInputBehavior , TextBoxDoubleInputBehavior .

Vous pouvez utiliser une expression régulière avec les événements PreviewTextInput , DataObject.Pasting et PreviewKeyDown sur une TextBox pour vérifier si la nouvelle chaîne correspond à une regex , si ce n'est pas le cas, vous pouvez annuler l'opération.

Comme ça:

xaml code >:

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
xmlns:cmd ="http://www.galasoft.ch/mvvmlight"

...

<TextBox>
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="PreviewTextInput">
            <cmd:EventToCommand Command="{Binding Mode=OneWay, Path=PreviewTextInputCommand}" PassEventArgsToCommand="True" />
        </i:EventTrigger>
        <i:EventTrigger EventName="DataObject.Pasting">
            <cmd:EventToCommand Command="{Binding Mode=OneWay, Path=DataObject_PastingCommand}" PassEventArgsToCommand="True" />
        </i:EventTrigger>
        <i:EventTrigger EventName="PreviewKeyDown">
            <cmd:EventToCommand Command="{Binding Mode=OneWay, Path=PreviewKeyDownCommand}" PassEventArgsToCommand="True" />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</TextBox>

Code derrière:

public partial class MainWindow : Window
{
    private Regex gramOrMilliGramRegex = new Regex("^[0-9.-]+(m?g)?$");

    public MainWindow ()
    {
        InitializeComponent();
    }

    private void txtbox_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        if(sender is TextBox txtbox)
        {
            string newString = txtbox.Text.Substring(0, txtbox.CaretIndex) + e.Text + txtbox.Text.Substring(txtbox.CaretIndex); //Build the new string
            e.Handled = !gramOrMilliGramRegex.IsMatch(e.Text); //Check if it matches the regex
        }

    }

    private void txtbox_Pasting(object sender, DataObjectPastingEventArgs e)
    {
        if(sender is TextBox txtbox)
        {
            string newString = txtbox.Text.Substring(0, txtbox.CaretIndex) + e.DataObject.GetData(typeof(string)) as string + txtbox.Text.Substring(txtbox.CaretIndex); //Build new string
            if (!digitOnlyRegex.IsMatch(newString)) //Check if it matches the regex
            {
                e.CancelCommand();
            }
        }

    private void txtbox_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        //Prevents whitespace
        if (e.Key == Key.Space)
        {
            e.Handled = true;
        }
        base.OnPreviewKeyDown(e);
    }
}

MISE À JOUR: Comme vous le mentionnez maintenant, vous utilisez MVVM et ne voulez pas enfreindre le modèle.

Vous devrez acheminer ces événements vers les commandes de votre ViewModel et placer le événements ci-dessus.

Vous pouvez le faire en utilisant ce code dans votre TextBox dans le xaml:

...
<TextBox PreviewTextInput="txtbox_PreviewTextInput" DataObject.Pasting="txtbox_Pasting" PreviewKeyDown="txtbox_PreviewKeyDown" />
...

En raison de la nature de cette entrée, je vous suggère de créer un petit CustomControl , plus spécifique un TextBox qui est capable de limiter la Input et convertissez le Text en la valeur correspondante -> un GramTextBox .

Le GramTextBox a un DependencyProperty appelé Gram qui représente la valeur du Text saisi et peut être lié à un ViewModel (REMARQUE: la liaison doit contenir Mode = TwoWay car GramTextBox essaie de mettre à jour la Source) liée .

<DataGrid AutoGenerateColumns="False" ... >
    <DataGrid.Columns>
       <!-- Put some other Columns here like DataGridTextColumn -->
       <DataGridTemplateColumn Header="Mass">
           <DataGridTemplateColumn.CellTemplate>
               <DataTemplate>
                   <cc:GramTextBox Gram="{Binding VMDoubleProperty, Mode=TwoWay}" ... />
               </DataTemplate>
           </DataGridTemplateColumn.CellTemplate>
       </DataGridTemplateColumn>
       <!-- Put some other Columns here -->
   </DataGrid.Columns>
</DataGrid> 

Utilisation

Mettez cette Classe dans YOURNAMESPACE et dans le XAML ajouter un alias d'espace de noms

<cc:GramTextBox Gram="{Binding VMDoubleProperty, Mode=TwoWay}" ... />

La GramTextBox peut maintenant être utilisée comme ceci

xmlns:cc="clr-namespace:YOURNAMESPACE"

il mettra à jour la Propriété liée dans ViewModel chaque fois que le Texte du Modifications de GramTextBox (par exemple. entrées valides du clavier / coller, etc.).

Notes

Il est prévu que les entrées absurdes telles que .00g , 0.0m , .mg définissez la Gram Property sur 0 (comme une valeur de repli) .

Note personnelle

Merci @Pavel pour le PasteHandler

Modifier strong>

Pour utiliser ce GramTextBox dans un DataGrid , vous pouvez remplacer le CellTemplate de la Colonne :

public sealed class GramTextBox : TextBox
{
    //Constructor
    public GramTextBox() : base()
    {
        Text = "0g"; //Initial value
        TextChanged += OnTextChanged;
        DataObject.AddPastingHandler(this, OnPaste);
    }

    //Style override (get the Style of a TextBox for the GramTextBox)
    static GramTextBox()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(GramTextBox), new FrameworkPropertyMetadata(typeof(TextBox)));
    }

    //Define a DependencyProperty to make it bindable (dont forget 'Mode=TwoWay' due the bound value is updated from this GramTextBox)
    [Category("Common"), Description("Converted double value from the entered Text in gram")]
    [Browsable(true)]
    [Bindable(true)]
    public double Gram
    {
        get { return (double)GetValue(PathDataProperty); }
        set { SetCurrentValue(PathDataProperty, value); }
    }
    public static DependencyProperty PathDataProperty = DependencyProperty.Register("Gram", typeof(double), typeof(GramTextBox), new PropertyMetadata(0d));

    //Extract the Gram value when Text has changed
    private void OnTextChanged(object sender, TextChangedEventArgs e)
    {
        ExtractGram(Text);
    }

    //Suppress space input
    protected override void OnPreviewKeyDown(KeyEventArgs e)
    {
        e.Handled = e.Key == Key.Space;
    }

    //Check text inputs
    protected override void OnPreviewTextInput(TextCompositionEventArgs e)
    {
        e.Handled = !IsValidText(Text.Insert(CaretIndex, e.Text));
    }

    //check paste inputs
    private void OnPaste(object sender, DataObjectPastingEventArgs e)
    {
        //Check if pasted object is string
        if(e.SourceDataObject.GetData(typeof(string)) is string text)
        {
            //Check if combined string is valid
           if(!IsValidText(Text.Insert(CaretIndex, text))) { e.CancelCommand(); }
        }
        else { e.CancelCommand(); }
    }

    //Check valid format for extraction (supports incomplete inputs like 0.m -> 0g)
    private bool IsValidText(string text)
    {
        return Regex.IsMatch(text, @"^([0-9]*?\.?[0-9]*?m?g?)$");
    }

    //Extract value from entered string
    private void ExtractGram(string text)
    {
        //trim all unwanted characters (only allow 0-9 dots and m or g)
        text = Regex.Replace(text, @"[^0-9\.mg]", String.Empty);
        //Expected Format -> random numbers, dots and couple m/g

        //trim all text after the letter g 
        text = text.Split('g')[0];
        //Expected Format -> random numbers, dots and m

        //trim double dots (only one dot is allowed)
        text = Regex.Replace(text, @"(?<=\..*)(\.)", String.Empty);
        //Expected Format -> random numbers with one or more dots and m

        //Check if m is at the end of the string to indicate milli (g was trimmed earlier)
        bool isMilli = text.EndsWith("m");

        //Remove all m, then only a double number should remain
        text = text.Replace("m", String.Empty);
        //Expected Format -> random numbers with possible dot

        //trim all leading zeros
        text = text.TrimStart(new char[] { '0' });
        //Expected Format -> random numbers with possible dot

        //Check if dot is at the beginning
        if (text.StartsWith(".")) { text = $"0{text}"; }
        //Expected Format -> random numbers with possible dot

        //Check if dot is at the end
        if (text.EndsWith(".")) { text = $"{text}0"; }
        //Expected Format -> random numbers with possible dot

        //Try to convert the remaining String to a Number, if it fails -> 0
        Double.TryParse(text, out double result);

        //Update Gram Property (divide when necessary)
        Gram = (isMilli) ? result / 1000d : result;
    }
}