Wie TextBox Eingangs Einschränkungen definieren?

Question

Wie kann ich beschränken TextBox nur Großbuchstaben, oder beispielsweise Ziffern zu akzeptieren, oder verbieten keine Sonderzeichen setzen?

Sicher ist es ein Stück Kuchen TextInput- Veranstaltung und behandeln Sie den Text hier zu fangen, aber es ist der richtige Weg, dies zu tun?

Answer 1

Ich habe dies in der Vergangenheit mit einem daran befestigten Verhalten getan, die wie folgt verwendet werden:

<TextBox b:Masking.Mask="^\p{Lu}*$"/>

Mit dem beigefügten Verhalten Code sieht wie folgt aus:

/// <summary>
/// Provides masking behavior for any <see cref="TextBox"/>.
/// </summary>
public static class Masking
{
    private static readonly DependencyPropertyKey _maskExpressionPropertyKey = DependencyProperty.RegisterAttachedReadOnly("MaskExpression",
        typeof(Regex),
        typeof(Masking),
        new FrameworkPropertyMetadata());

    /// <summary>
    /// Identifies the <see cref="Mask"/> dependency property.
    /// </summary>
    public static readonly DependencyProperty MaskProperty = DependencyProperty.RegisterAttached("Mask",
        typeof(string),
        typeof(Masking),
        new FrameworkPropertyMetadata(OnMaskChanged));

    /// <summary>
    /// Identifies the <see cref="MaskExpression"/> dependency property.
    /// </summary>
    public static readonly DependencyProperty MaskExpressionProperty = _maskExpressionPropertyKey.DependencyProperty;

    /// <summary>
    /// Gets the mask for a given <see cref="TextBox"/>.
    /// </summary>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask is to be retrieved.
    /// </param>
    /// <returns>
    /// The mask, or <see langword="null"/> if no mask has been set.
    /// </returns>
    public static string GetMask(TextBox textBox)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        return textBox.GetValue(MaskProperty) as string;
    }

    /// <summary>
    /// Sets the mask for a given <see cref="TextBox"/>.
    /// </summary>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask is to be set.
    /// </param>
    /// <param name="mask">
    /// The mask to set, or <see langword="null"/> to remove any existing mask from <paramref name="textBox"/>.
    /// </param>
    public static void SetMask(TextBox textBox, string mask)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        textBox.SetValue(MaskProperty, mask);
    }

    /// <summary>
    /// Gets the mask expression for the <see cref="TextBox"/>.
    /// </summary>
    /// <remarks>
    /// This method can be used to retrieve the actual <see cref="Regex"/> instance created as a result of setting the mask on a <see cref="TextBox"/>.
    /// </remarks>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask expression is to be retrieved.
    /// </param>
    /// <returns>
    /// The mask expression as an instance of <see cref="Regex"/>, or <see langword="null"/> if no mask has been applied to <paramref name="textBox"/>.
    /// </returns>
    public static Regex GetMaskExpression(TextBox textBox)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        } 

        return textBox.GetValue(MaskExpressionProperty) as Regex;
    }

    private static void SetMaskExpression(TextBox textBox, Regex regex)
    {
        textBox.SetValue(_maskExpressionPropertyKey, regex);
    }

    private static void OnMaskChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var textBox = dependencyObject as TextBox;
        var mask = e.NewValue as string;
        textBox.PreviewTextInput -= textBox_PreviewTextInput;
        textBox.PreviewKeyDown -= textBox_PreviewKeyDown;
        DataObject.RemovePastingHandler(textBox, Pasting);

        if (mask == null)
        {
            textBox.ClearValue(MaskProperty);
            textBox.ClearValue(MaskExpressionProperty);
        }
        else
        {
            textBox.SetValue(MaskProperty, mask);
            SetMaskExpression(textBox, new Regex(mask, RegexOptions.Compiled | RegexOptions.IgnorePatternWhitespace));
            textBox.PreviewTextInput += textBox_PreviewTextInput;
            textBox.PreviewKeyDown += textBox_PreviewKeyDown;
            DataObject.AddPastingHandler(textBox, Pasting);
        }
    }

    private static void textBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        if (maskExpression == null)
        {
            return;
        }

        var proposedText = GetProposedText(textBox, e.Text);

        if (!maskExpression.IsMatch(proposedText))
        {
            e.Handled = true;
        }
    }

    private static void textBox_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        if (maskExpression == null)
        {
            return;
        }

        //pressing space doesn't raise PreviewTextInput - no idea why, but we need to handle
        //explicitly here
        if (e.Key == Key.Space)
        {
            var proposedText = GetProposedText(textBox, " ");

            if (!maskExpression.IsMatch(proposedText))
            {
                e.Handled = true;
            }
        }
    }

    private static void Pasting(object sender, DataObjectPastingEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        if (maskExpression == null)
        {
            return;
        }

        if (e.DataObject.GetDataPresent(typeof(string)))
        {
            var pastedText = e.DataObject.GetData(typeof(string)) as string;
            var proposedText = GetProposedText(textBox, pastedText);

            if (!maskExpression.IsMatch(proposedText))
            {
                e.CancelCommand();
            }
        }
        else
        {
            e.CancelCommand();
        }
    }

    private static string GetProposedText(TextBox textBox, string newText)
    {
        var text = textBox.Text;

        if (textBox.SelectionStart != -1)
        {
            text = text.Remove(textBox.SelectionStart, textBox.SelectionLength);
        }

        text = text.Insert(textBox.CaretIndex, newText);

        return text;
    }
}

Answer 2

Ich habe Antwort Kent Boogaart der verbessert, indem auch die folgenden Aktionen Handhabung, die zuvor das Muster verletzt wird dazu führen können:

• Rücktaste
• Auswählen und Ziehen von Text in einer Weise, die das Muster verletzen kann
• Cut-Befehl

Zum Beispiel erlaubt Kent Boogaart Antwort der Benutzer zur Eingabe von „ac“, indem man zuerst „abc“ eingeben und anschließend den „b“ mit dem Backspace löschen, die folgenden regex verletzt

^(a|ab|abc)$

Verbrauch (unverändert):

<TextBox b:Masking.Mask="^\p{Lu}*$"/>

Maske Klasse:

public static class Masking
{
    private static readonly DependencyPropertyKey _maskExpressionPropertyKey = DependencyProperty.RegisterAttachedReadOnly("MaskExpression",
            typeof(Regex),
            typeof(Masking),
            new FrameworkPropertyMetadata());

    /// <summary>
    /// Identifies the <see cref="Mask"/> dependency property.
    /// </summary>
    public static readonly DependencyProperty MaskProperty = DependencyProperty.RegisterAttached("Mask",
            typeof(string),
            typeof(Masking),
            new FrameworkPropertyMetadata(OnMaskChanged));

    /// <summary>
    /// Identifies the <see cref="MaskExpression"/> dependency property.
    /// </summary>
    public static readonly DependencyProperty MaskExpressionProperty = _maskExpressionPropertyKey.DependencyProperty;

    /// <summary>
    /// Gets the mask for a given <see cref="TextBox"/>.
    /// </summary>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask is to be retrieved.
    /// </param>
    /// <returns>
    /// The mask, or <see langword="null"/> if no mask has been set.
    /// </returns>
    public static string GetMask(TextBox textBox)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        return textBox.GetValue(MaskProperty) as string;
    }

    /// <summary>
    /// Sets the mask for a given <see cref="TextBox"/>.
    /// </summary>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask is to be set.
    /// </param>
    /// <param name="mask">
    /// The mask to set, or <see langword="null"/> to remove any existing mask from <paramref name="textBox"/>.
    /// </param>
    public static void SetMask(TextBox textBox, string mask)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        textBox.SetValue(MaskProperty, mask);
    }

    /// <summary>
    /// Gets the mask expression for the <see cref="TextBox"/>.
    /// </summary>
    /// <remarks>
    /// This method can be used to retrieve the actual <see cref="Regex"/> instance created as a result of setting the mask on a <see cref="TextBox"/>.
    /// </remarks>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask expression is to be retrieved.
    /// </param>
    /// <returns>
    /// The mask expression as an instance of <see cref="Regex"/>, or <see langword="null"/> if no mask has been applied to <paramref name="textBox"/>.
    /// </returns>
    public static Regex GetMaskExpression(TextBox textBox)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        return textBox.GetValue(MaskExpressionProperty) as Regex;
    }

    private static void SetMaskExpression(TextBox textBox, Regex regex)
    {
        textBox.SetValue(_maskExpressionPropertyKey, regex);
    }

    private static void OnMaskChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var textBox = dependencyObject as TextBox;
        var mask = e.NewValue as string;
        textBox.PreviewTextInput -= textBox_PreviewTextInput;
        textBox.PreviewKeyDown -= textBox_PreviewKeyDown;
        DataObject.RemovePastingHandler(textBox, Pasting);
        DataObject.RemoveCopyingHandler(textBox, NoDragCopy);
        CommandManager.RemovePreviewExecutedHandler(textBox, NoCutting);


        if (mask == null)
        {
            textBox.ClearValue(MaskProperty);
            textBox.ClearValue(MaskExpressionProperty);
        }
        else
        {
            textBox.SetValue(MaskProperty, mask);
            SetMaskExpression(textBox, new Regex(mask, RegexOptions.Compiled | RegexOptions.IgnorePatternWhitespace));
            textBox.PreviewTextInput += textBox_PreviewTextInput;
            textBox.PreviewKeyDown += textBox_PreviewKeyDown;
            DataObject.AddPastingHandler(textBox, Pasting);
            DataObject.AddCopyingHandler(textBox, NoDragCopy);
            CommandManager.AddPreviewExecutedHandler(textBox, NoCutting);
        }
    }

    private static void NoCutting(object sender, ExecutedRoutedEventArgs e)
    {
        if(e.Command == ApplicationCommands.Cut)
        {
            e.Handled = true;
        }
    }

    private static void NoDragCopy(object sender, DataObjectCopyingEventArgs e)
    {
        if (e.IsDragDrop)
        {
            e.CancelCommand();
        }
    }

    private static void textBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        if (maskExpression == null)
        {
            return;
        }

        var proposedText = GetProposedText(textBox, e.Text);

        if (!maskExpression.IsMatch(proposedText))
        {
            e.Handled = true;
        }
    }

    private static void textBox_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        if (maskExpression == null)
        {
            return;
        }

        string proposedText = null;

        //pressing space doesn't raise PreviewTextInput, reasons here http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/446ec083-04c8-43f2-89dc-1e2521a31f6b?prof=required
        if (e.Key == Key.Space)
        {
            proposedText = GetProposedText(textBox, " ");
        }
        // Same story with backspace
        else if(e.Key == Key.Back)
        {
            proposedText = GetProposedTextBackspace(textBox);
        }

        if (proposedText != null && proposedText != string.Empty && !maskExpression.IsMatch(proposedText))
        {
            e.Handled = true;
        }

    }

    private static void Pasting(object sender, DataObjectPastingEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        if (maskExpression == null)
        {
            return;
        }

        if (e.DataObject.GetDataPresent(typeof(string)))
        {
            var pastedText = e.DataObject.GetData(typeof(string)) as string;
            var proposedText = GetProposedText(textBox, pastedText);

            if (!maskExpression.IsMatch(proposedText))
            {
                e.CancelCommand();
            }
        }
        else
        {
            e.CancelCommand();
        }
    }

    private static string GetProposedTextBackspace(TextBox textBox)
    {
        var text = GetTextWithSelectionRemoved(textBox);
        if (textBox.SelectionStart > 0 && textBox.SelectionLength == 0)
        {
            text = text.Remove(textBox.SelectionStart-1, 1);
        }

        return text;
    }


    private static string GetProposedText(TextBox textBox, string newText)
    {
        var text = GetTextWithSelectionRemoved(textBox);
        text = text.Insert(textBox.CaretIndex, newText);

        return text;
    }

    private static string GetTextWithSelectionRemoved(TextBox textBox)
    {
        var text = textBox.Text;

        if (textBox.SelectionStart != -1)
        {
            text = text.Remove(textBox.SelectionStart, textBox.SelectionLength);
        }
        return text;
    }
}

Answer 3

Ich änderte VitalyB Code Farbe Themen zu unterstützen. Stattdessen Benutzereingaben zu blockieren, wenn es nicht das RegEx Skript nicht erfüllt, es unterstreicht nur das Textfeld ein. Das Textfeld wird das Thema Standard sein, ohne Interaktion und dann standardmäßig auf ein Licht grün oder rot auf dem Wert je nach dem Eingang gesetzt ist. Sie können auch die scheitern und übergeben Farben programmatisch mit ein:

b:ColorMasking.PassColor = "Hexadecimal Value"
b:ColorMasking.FailColor = "Hexadecimal Value"

Die Klasse ist unter:

public class ColorMasking : DependencyObject
{
    private static readonly DependencyPropertyKey _maskExpressionPropertyKey = DependencyProperty.RegisterAttachedReadOnly("MaskExpression",
            typeof(Regex),
            typeof(ColorMasking),
            new FrameworkPropertyMetadata());

    /// <summary>
    /// Identifies the <see cref="Mask"/> dependency property.
    /// </summary>
    /// 
    public static readonly DependencyProperty PassColorProperty = DependencyProperty.RegisterAttached("PassColor",
            typeof(string),
            typeof(ColorMasking),
            new PropertyMetadata("#99FF99"));

    public static void SetPassColor(DependencyObject obj, string passColor)
    {
        obj.SetValue(PassColorProperty, passColor);
    }

    public static string GetPassColor(DependencyObject obj)
    {
        return (string)obj.GetValue(PassColorProperty);
    }


    public static readonly DependencyProperty FailColorProperty = DependencyProperty.RegisterAttached("FailColor",
            typeof(string),
            typeof(ColorMasking),
            new PropertyMetadata("#FFCCFF"));

    public static void SetFailColor(DependencyObject obj, string failColor)
    {
        obj.SetValue(FailColorProperty, failColor);
    }

    public static string GetFailColor(DependencyObject obj)
    {
        return (string)obj.GetValue(FailColorProperty);
    }

    public static readonly DependencyProperty MaskProperty = DependencyProperty.RegisterAttached("Mask",
            typeof(string),
            typeof(ColorMasking),
            new FrameworkPropertyMetadata(OnMaskChanged));

    private static void OnPassColorChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var textBox = dependencyObject as TextBox;
        var color = e.NewValue as string;
        textBox.SetValue(PassColorProperty, color);
    }

    /// <summary>
    /// Identifies the <see cref="MaskExpression"/> dependency property.
    /// </summary>
    public static readonly DependencyProperty MaskExpressionProperty = _maskExpressionPropertyKey.DependencyProperty;

    /// <summary>
    /// Gets the mask for a given <see cref="TextBox"/>.
    /// </summary>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask is to be retrieved.
    /// </param>
    /// <returns>
    /// The mask, or <see langword="null"/> if no mask has been set.
    /// </returns>
    public static string GetMask(TextBox textBox)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        return textBox.GetValue(MaskProperty) as string;
    }

    /// <summary>
    /// Sets the mask for a given <see cref="TextBox"/>.
    /// </summary>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask is to be set.
    /// </param>
    /// <param name="mask">
    /// The mask to set, or <see langword="null"/> to remove any existing mask from <paramref name="textBox"/>.
    /// </param>
    public static void SetMask(TextBox textBox, string mask)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        textBox.SetValue(MaskProperty, mask);
    }

    /// <summary>
    /// Gets the mask expression for the <see cref="TextBox"/>.
    /// </summary>
    /// <remarks>
    /// This method can be used to retrieve the actual <see cref="Regex"/> instance created as a result of setting the mask on a <see cref="TextBox"/>.
    /// </remarks>
    /// <param name="textBox">
    /// The <see cref="TextBox"/> whose mask expression is to be retrieved.
    /// </param>
    /// <returns>
    /// The mask expression as an instance of <see cref="Regex"/>, or <see langword="null"/> if no mask has been applied to <paramref name="textBox"/>.
    /// </returns>
    public static Regex GetMaskExpression(TextBox textBox)
    {
        if (textBox == null)
        {
            throw new ArgumentNullException("textBox");
        }

        return textBox.GetValue(MaskExpressionProperty) as Regex;
    }

    private static void SetMaskExpression(TextBox textBox, Regex regex)
    {
        textBox.SetValue(_maskExpressionPropertyKey, regex);
    }

    private static void OnMaskChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var textBox = dependencyObject as TextBox;
        var mask = e.NewValue as string;
        textBox.PreviewTextInput -= textBox_PreviewTextInput;
        textBox.PreviewKeyDown -= textBox_PreviewKeyDown;
        DataObject.RemovePastingHandler(textBox, Pasting);
        DataObject.RemoveCopyingHandler(textBox, NoDragCopy);
        CommandManager.RemovePreviewExecutedHandler(textBox, NoCutting);

        if (mask == null)
        {
            textBox.ClearValue(MaskProperty);
            textBox.ClearValue(MaskExpressionProperty);
        }
        else
        {
            textBox.SetValue(MaskProperty, mask);
            SetMaskExpression(textBox, new Regex(mask, RegexOptions.Compiled | RegexOptions.IgnorePatternWhitespace));
            textBox.PreviewTextInput += textBox_PreviewTextInput;
            textBox.PreviewKeyDown += textBox_PreviewKeyDown;
            DataObject.AddPastingHandler(textBox, Pasting);
            DataObject.AddCopyingHandler(textBox, NoDragCopy);
            CommandManager.AddPreviewExecutedHandler(textBox, NoCutting);
        }
    }

    private static void NoCutting(object sender, ExecutedRoutedEventArgs e)
    {
        if (e.Command == ApplicationCommands.Cut)
        {
            e.Handled = true;
        }
    }

    private static void NoDragCopy(object sender, DataObjectCopyingEventArgs e)
    {
        if (e.IsDragDrop)
        {
            e.CancelCommand();
        }
    }

    private static void textBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        string passHex = (string)textBox.GetValue(PassColorProperty);
        string failHex = (string)textBox.GetValue(FailColorProperty);
        Color passColor = Extensions.ToColorFromHex(passHex);
        Color failColor = Extensions.ToColorFromHex(failHex);

        if (maskExpression == null)
        {
            return;
        }

        var proposedText = GetProposedText(textBox, e.Text);

        if (!maskExpression.IsMatch(proposedText))
        {
            textBox.Background = new SolidColorBrush(failColor);
        }
        else
        {
            textBox.Background = new SolidColorBrush(passColor);
        }
    }

    private static void textBox_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        var textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        string passHex = (string)textBox.GetValue(PassColorProperty);
        string failHex = (string)textBox.GetValue(FailColorProperty);
        Color passColor = Extensions.ToColorFromHex(passHex);
        Color failColor = Extensions.ToColorFromHex(failHex);

        if (maskExpression == null)
        {
            return;
        }

        string proposedText = null;

        //pressing space doesn't raise PreviewTextInput, reasons here http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/446ec083-04c8-43f2-89dc-1e2521a31f6b?prof=required
        if (e.Key == Key.Space)
        {
            proposedText = GetProposedText(textBox, " ");
        }
        // Same story with backspace
        else if (e.Key == Key.Back)
        {
            proposedText = GetProposedTextBackspace(textBox);
        }

        if (proposedText != null && !maskExpression.IsMatch(proposedText))
        {
            textBox.Background = new SolidColorBrush(failColor);
        }
        else
        {
            textBox.Background = new SolidColorBrush(passColor);
        }

    }

    private static void Pasting(object sender, DataObjectPastingEventArgs e)
    {
        TextBox textBox = sender as TextBox;
        var maskExpression = GetMaskExpression(textBox);

        string passHex = (string)textBox.GetValue(PassColorProperty);
        string failHex = (string)textBox.GetValue(FailColorProperty);
        Color passColor = Extensions.ToColorFromHex(passHex);
        Color failColor = Extensions.ToColorFromHex(failHex);

        if (maskExpression == null)
        {
            return;
        }

        if (e.DataObject.GetDataPresent(typeof(string)))
        {
            var pastedText = e.DataObject.GetData(typeof(string)) as string;
            var proposedText = GetProposedText(textBox, pastedText);

            if (!maskExpression.IsMatch(proposedText))
            {
                textBox.Background = new SolidColorBrush(failColor);
            }
            else
            {
                textBox.Background = new SolidColorBrush(passColor);
            }
        }
        else
        {
            textBox.Background = new SolidColorBrush(failColor);
        }
    }

    private static string GetProposedTextBackspace(TextBox textBox)
    {
        var text = GetTextWithSelectionRemoved(textBox);
        if (textBox.SelectionStart > 0)
        {
            text = text.Remove(textBox.SelectionStart - 1, 1);
        }

        return text;
    }


    private static string GetProposedText(TextBox textBox, string newText)
    {
        var text = GetTextWithSelectionRemoved(textBox);
        text = text.Insert(textBox.CaretIndex, newText);

        return text;
    }

    private static string GetTextWithSelectionRemoved(TextBox textBox)
    {
        var text = textBox.Text;

        if (textBox.SelectionStart != -1)
        {
            text = text.Remove(textBox.SelectionStart, textBox.SelectionLength);
        }
        return text;
    }
}

So führen Sie das Skript eine Klasse von Aaron C geschrieben erfordert, erklärt hier: Silverlight / WPF setzt Ellipse mit hexadezimalen Farb hier gezeigt: http: //www.wiredprairie.us/blog/index.php/archives/659

Der Code für den Fall, wird im Folgenden die Website immer bewegt:

public static class Extensions
{
    public static void SetFromHex(this Color c, string hex)
    {
        Color c1 = ToColorFromHex(hex);

        c.A = c1.A;
        c.R = c1.R;
        c.G = c1.G;
        c.B = c1.B;
    }

    public static Color ToColorFromHex(string hex)
    {
        if (string.IsNullOrEmpty(hex))
        {
            throw new ArgumentNullException("hex");
        }

        // remove any "#" characters
        while (hex.StartsWith("#"))
        {
            hex = hex.Substring(1);
        }

        int num = 0;
        // get the number out of the string
        if (!Int32.TryParse(hex, System.Globalization.NumberStyles.HexNumber, null, out num))
        {
            throw new ArgumentException("Color not in a recognized Hex format.");
        }

        int[] pieces = new int[4];
        if (hex.Length > 7)
        {
            pieces[0] = ((num >> 24) & 0x000000ff);
            pieces[1] = ((num >> 16) & 0x000000ff);
            pieces[2] = ((num >> 8) & 0x000000ff);
            pieces[3] = (num & 0x000000ff);
        }
        else if (hex.Length > 5)
        {
            pieces[0] = 255;
            pieces[1] = ((num >> 16) & 0x000000ff);
            pieces[2] = ((num >> 8) & 0x000000ff);
            pieces[3] = (num & 0x000000ff);
        }
        else if (hex.Length == 3)
        {
            pieces[0] = 255;
            pieces[1] = ((num >> 8) & 0x0000000f);
            pieces[1] += pieces[1] * 16;
            pieces[2] = ((num >> 4) & 0x000000f);
            pieces[2] += pieces[2] * 16;
            pieces[3] = (num & 0x000000f);
            pieces[3] += pieces[3] * 16;
        }
        return Color.FromArgb((byte)pieces[0], (byte)pieces[1], (byte)pieces[2], (byte)pieces[3]);
    }

}

Answer 4

private void TextBox1_SelectionChanged(object sender, RoutedEventArgs e)
{
    string txt = TextBox1.Text;
    if (txt != "")
    {
        TextBox1.Text = Regex.Replace(TextBox1.Text, "[^0-9]", "");
        if (txt != TextBox1.Text)
        {
            TextBox1.Select(TextBox1.Text.Length, 0);
        }
    }
}

Answer 5

Hier ist noch eine weitere Version der bestehenden Lösungen hier. Es ist ein Verhalten ein „TextChanging“ Ereignis den alten Text, den neuen Text und eine Fahne Simulation bietet die Änderung abzubrechen. So können wir umsetzen können, was wir wollen, Filter.

habe ich von dem „PreviewKeyDown“ Handler nur für das Leerzeichen verwendet befreien. TextBox scheint alles mit gerouteten Befehle zu verwalten und „Space“ hat seine eigene commmand haben, aber es ist nicht öffentlich ist. Ich habe auch die Unterstützung für additionals Tastenkombinationen wie „Strg + Backspace“ (vorherige Wort löschen).

public class TextChangingBehavior : Behavior<TextBox>
{
    public event EventHandler<TextChangingEventArgs> TextChanging;

    protected override void OnAttached()
    {
        base.OnAttached();

        AssociatedObject.PreviewTextInput += OnPreviewTextInput;
        CommandManager.AddPreviewExecutedHandler(AssociatedObject, OnPreviewExecutedHandler);
        DataObject.AddCopyingHandler(AssociatedObject, OnCopying);
        DataObject.AddPastingHandler(AssociatedObject, OnPasting);
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();

        AssociatedObject.PreviewTextInput -= OnPreviewTextInput;
        CommandManager.RemovePreviewExecutedHandler(AssociatedObject, OnPreviewExecutedHandler);
        DataObject.RemoveCopyingHandler(AssociatedObject, OnCopying);
        DataObject.RemovePastingHandler(AssociatedObject, OnPasting);
    }

    #region Text

    private enum CharCategory
    {
        LetterOrDigit,
        Whitespace,
        Other
    }

    private CharCategory GetCharCategory(char c)
    {
        if (char.IsLetterOrDigit(c))
            return CharCategory.LetterOrDigit;
        else if (char.IsWhiteSpace(c))
            return CharCategory.Whitespace;
        else
            return CharCategory.Other;
    }

    private string GetText(string input = null)
    {
        var box = AssociatedObject;
        var text = box.Text ?? string.Empty;
        if (input != null)
        {
            // Delete selection
            var deleteCount = box.SelectionLength;
            if (deleteCount > 0)
                text = text.Remove(box.SelectionStart, deleteCount);
            // Insert input
            if (input.Length > 0)
                text = text.Insert(box.CaretIndex, input);
        }
        return text;
    }

    #endregion

    private void OnPreviewExecutedHandler(object sender, ExecutedRoutedEventArgs e)
    {
        var box = AssociatedObject;
        var selectionExists = box.SelectionLength > 0;
        var caretIndex = box.CaretIndex;
        string newText = null;

        if (e.Command == ApplicationCommands.Cut)
        {
            if (selectionExists)
                newText = GetText(string.Empty);
        }
        else if (e.Command == EditingCommands.Backspace)
        {
            if (selectionExists)
                newText = GetText(string.Empty);
            else if (caretIndex > 0)
                newText = GetText().Remove(caretIndex - 1, 1);
        }
        else if (e.Command == EditingCommands.Delete)
        {
            if (selectionExists)
                newText = GetText(string.Empty);
            else
            {
                newText = GetText();
                if (caretIndex >= newText.Length)
                    newText = null;
                else
                    newText = newText.Remove(caretIndex, 1);
            }
        }
        else if (e.Command == EditingCommands.DeletePreviousWord)
        {
            if (selectionExists)
                newText = GetText(string.Empty);
            else if (caretIndex > 0)
            {
                newText = GetText();
                var startIndex = caretIndex;
                // Include whitespaces
                do
                    startIndex--;
                while (startIndex > 0 && char.IsWhiteSpace(newText[startIndex]));
                // Include the next block
                var currentCategory = GetCharCategory(newText[startIndex]);
                while (startIndex > 0 && GetCharCategory(newText[startIndex - 1]) == currentCategory)
                    startIndex--;

                newText = newText.Remove(startIndex, caretIndex - startIndex);
            }
        }
        else if (e.Command == EditingCommands.DeleteNextWord)
        {
            if (selectionExists)
                newText = GetText(string.Empty);
            else
            {
                newText = GetText();
                if (caretIndex >= newText.Length)
                    newText = null;
                else
                {
                    var endIndex = caretIndex + 1;
                    // Include the current block
                    var currentCategory = GetCharCategory(newText[caretIndex]);
                    while (endIndex < newText.Length && GetCharCategory(newText[endIndex]) == currentCategory)
                        endIndex++;
                    // Include whitespaces
                    while (endIndex < newText.Length && char.IsWhiteSpace(newText[endIndex]))
                        endIndex++;

                    newText = newText.Remove(caretIndex, endIndex - caretIndex);
                }
            }
        }
        else if (e.Command is RoutedUICommand cmd && new[] { "Space", "ShiftSpace" }.Contains(cmd.Name))
        {
            newText = GetText(" ");
        }

        if (newText != null && OnProcessChange(newText))
            e.Handled = true;
    }

    private void OnCopying(object sender, DataObjectCopyingEventArgs e)
    {
        if (e.IsDragDrop)
        {
            if (OnProcessChange(GetText(string.Empty)))
                e.CancelCommand();
        }
    }

    private void OnPasting(object sender, DataObjectPastingEventArgs e)
    {
        if (e.DataObject.GetDataPresent(typeof(string)))
        {
            if (OnProcessChange(GetText((string)e.DataObject.GetData(typeof(string)))))
                e.CancelCommand();
        }
    }

    private void OnPreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        if (!string.IsNullOrEmpty(e.Text))
        {
            if (OnProcessChange(GetText(e.Text)))
                e.Handled = true;
        }
    }

    private bool OnProcessChange(string newValue)
    {
        var oldValue = GetText();

        if (string.Equals(oldValue, newValue, StringComparison.Ordinal))
            return false;
        else
        {
            var args = new TextChangingEventArgs(oldValue, newValue);
            OnTextChanging(args);
            return args.Cancel;
        }
    }

    protected virtual void OnTextChanging(TextChangingEventArgs e)
    {
        TextChanging?.Invoke(this, e);
    }
}

public class TextChangingEventArgs : EventArgs
{
    public string OldValue { get; }

    public string NewValue { get; }

    public bool Cancel { get; set; }

    public TextChangingEventArgs(string oldValue, string newValue)
    {
        OldValue = oldValue;
        NewValue = newValue;
    }
}

Answer 6

Eine andere mögliche Lösung ist eine der „Masked TextBox“ wpf Implementierung zu verwenden, um die „MaskedTextProvider“-Klasse, die von der „MaskedTextBox“ von WinForms verwendet wird.

Zwei mögliche Lösungen finden Sie hier -> https://wpftoolkit.codeplex.com/wikipage? title = MaskedTextBox und hier -> http: //marlongrech.wordpress .com / 2007/10/28 / maskierte Textbox /