数字文本框-使用Double.TryParse

本文关键字：Double TryParse 使用 文本 数字 | 更新日期: 2023-09-27 18:22:28

我知道这是一个古老的问题，有很多答案，但我还没有找到任何好的、可靠的答案。

要求是一个文本框，它将始终包含Double.TryParse将在.上返回true的字符串

我看到的大多数实现都不防止输入，比如："10.45.8"。这是一个问题。

最好的方法是完全使用事件，例如TextInput和KeyDown（用于空格）。这些方法的问题是，在新文本更改之前（或更改后的旧文本）获取表示新文本的字符串非常复杂。TextChanged的问题在于它没有提供获取旧文本的方法。

如果你能在新文本更改之前以某种方式获得它，那将是最有帮助的，因为你可以用Double.TryParse测试它。不过可能有更好的解决方案。

最好的方法是什么？

这个问题的最佳答案是有几种方法并进行比较。

数字文本框-使用Double.TryParse

方法1

将TextChanged和KeyDown事件的组合用于TextBox。在KeyDown上，您可以将当前文本保存在文本框中，然后在TextChanged事件中执行Double.TryParse。如果输入的文本无效，则将恢复到旧的文本值。这看起来像：

private int oldIndex = 0;
private string oldText = String.Empty;
private void textBox1_TextChanged(object sender, TextChangedEventArgs e)
{
    double val;
    if (!Double.TryParse(textBox1.Text, out val))
    {
        textBox1.TextChanged -= textBox1_TextChanged;
        textBox1.Text = oldText;
        textBox1.CaretIndex = oldIndex;
        textBox1.TextChanged += textBox1_TextChanged;
    }
}
private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
    oldIndex = textBox1.CaretIndex;
    oldText = textBox1.Text;
}

CaratIndex有助于避免在验证失败时将光标移动到第一个位置，从而将用户惹恼。但是，此方法无法捕捉空格键的按下。它将允许像"1234.56"这样输入文本。此外，粘贴文本将不会得到正确验证。除此之外，我不喜欢在文本更新过程中扰乱事件处理程序。

方法2

这种方法应该能满足您的需求。

使用PreviewKeyDown和PreviewTextInput事件处理程序。通过观察这些事件并进行相应的处理，您不需要担心恢复到文本框中以前的文本值。PreviewKeyDown可用于监视和忽略空格键按压，PreviewTextInput可用于在分配新文本框值之前测试该值。

private void textBox1_PreviewKeyDown(object sender, KeyEventArgs e)
{
    if (e.Key == Key.Space)
    {
        e.Handled = true;
    }
}
private void textBox1_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    //Create a string combining the text to be entered with what is already there.
    //Being careful of new text positioning here, though it isn't truly necessary for validation of number format.
    int cursorPos = textBox1.CaretIndex;
    string nextText;
    if (cursorPos > 0)
    {
        nextText = textBox1.Text.Substring(0, cursorPos) + e.Text + textBox1.Text.Substring(cursorPos);
    }
    else
    {
        nextText = textBox1.Text + e.Text;
    }
    double testVal;
    if (!Double.TryParse(nextText, out testVal))
    {
        e.Handled = true;
    }
}

这种方法可以更好地在无效输入进入文本框之前捕获无效输入。但是，根据消息路由列表中的其他目的地，将事件设置为Handled可能会给您带来麻烦。这里没有处理的最后一件事是用户将无效输入粘贴到文本框中的能力。这可以通过添加此代码来处理，该代码是在WPF文本框中的粘贴事件的基础上构建的。

private void OnPaste(object sender, DataObjectPastingEventArgs e)
{
    double testVal;
    bool ok = false;
    var isText = e.SourceDataObject.GetDataPresent(System.Windows.DataFormats.Text, true);
    if (isText)
    {
        var text = e.SourceDataObject.GetData(DataFormats.Text) as string;
        if (Double.TryParse(text, out testVal))
        {
            ok = true;
        }
    }
    if (!ok)
    {
        e.CancelCommand();
    }
}

在InitializeComponent调用后添加带有以下代码的处理程序：

DataObject.AddPastingHandler(textBox1, new DataObjectPastingEventHandler(OnPaste));

TextBox没有提供PreviewTextChanged事件，每个人每次都应该发明轮子来模仿它，这真的很烦人。我最近解决了完全相同的问题，甚至在github上发布了我的解决方案作为WpfEx项目（看看TextBoxBehavior.cs和TextBoxDoubleValidator.cs）。

Adam S的回答很好，但我们也应该考虑其他一些角落的情况。

  1. 所选文本

在textBox_PreviewTextInput事件处理程序中计算结果文本时，我们应该考虑用户可以在文本框中选择一些文本，新的输入将替换它

private static void PreviewTextInputForDouble(object sender, 
    TextCompositionEventArgs e)
{
    // e.Text contains only new text and we should create full text manually
    var textBox = (TextBox)sender;
    string fullText;
    // If text box contains selected text we should replace it with e.Text
    if (textBox.SelectionLength > 0)
    {
        fullText = textBox.Text.Replace(textBox.SelectedText, e.Text);
    }
    else
    {
        // And only otherwise we should insert e.Text at caret position
        fullText = textBox.Text.Insert(textBox.CaretIndex, e.Text);
    }
    // Now we should validate our fullText, but not with
    // Double.TryParse. We should use more complicated validation logic.
    bool isTextValid = TextBoxDoubleValidator.IsValid(fullText);
    // Interrupting this event if fullText is invalid
    e.Handled = !isTextValid;
}

在处理OnPaste事件时，我们应该使用相同的逻辑。

  1. 正在验证文本

我们不能使用简单的Double.TryParse，因为用户可以键入"+"到类型"+.1"（"+.1"-对于double是绝对有效的字符串），因此我们的验证方法应该在"+"上返回true或"-"字符串（我甚至创建了一个名为TextBoxDoubleValidator的单独类和一组单元测试，因为这个逻辑非常重要）。

在深入研究实现之前，让我们看看一组单元测试，这些测试将涵盖验证方法的所有角落案例：

[TestCase("", Result = true)]
[TestCase(".", Result = true)]
[TestCase("-.", Result = true)]
[TestCase("-.1", Result = true)]
[TestCase("+", Result = true)]
[TestCase("-", Result = true)]
[TestCase(".0", Result = true)]
[TestCase("1.0", Result = true)]
[TestCase("+1.0", Result = true)]
[TestCase("-1.0", Result = true)]
[TestCase("001.0", Result = true)]
[TestCase(" ", Result = false)]
[TestCase("..", Result = false)]
[TestCase("..1", Result = false)]
[TestCase("1+0", Result = false)]
[TestCase("1.a", Result = false)]
[TestCase("1..1", Result = false)]
[TestCase("a11", Result = false)]
[SetCulture("en-US")]
public bool TestIsTextValid(string text)
{
    bool isValid = TextBoxDoubleValidator.IsValid(text);
    Console.WriteLine("'{0}' is {1}", text, isValid ? "valid" : "not valid");
    return isValid;
}

注意，我使用SetCulture（"en-US"）属性，因为十进制分隔符"local-specific".

我想我用这些测试涵盖了所有的角落案例，但有了这个工具，你可以很容易地"模拟"用户输入并检查（和重用）你想要的任何案例。现在我们来看一下TextBoxDoubleValidator.IsValid方法：

/// <summary> 
/// Helper class that validates text box input for double values. 
/// </summary> 
internal static class TextBoxDoubleValidator 
{ 
    private static readonly ThreadLocal<NumberFormatInfo> _numbersFormat = new ThreadLocal<NumberFormatInfo>( 
        () => Thread.CurrentThread.CurrentCulture.NumberFormat);
    /// <summary> 
    /// Returns true if input <param name="text"/> is accepted by IsDouble text box. 
    /// </summary> 
    public static bool IsValid(string text) 
    { 
        // First corner case: null or empty string is a valid text in our case 
        if (text.IsNullOrEmpty()) 
            return true;
        // '.', '+', '-', '+.' or '-.' - are invalid doubles, but we should accept them 
        // because user can continue typeing correct value (like .1, +1, -0.12, +.1, -.2) 
        if (text == _numbersFormat.Value.NumberDecimalSeparator || 
            text == _numbersFormat.Value.NegativeSign || 
            text == _numbersFormat.Value.PositiveSign || 
            text == _numbersFormat.Value.NegativeSign + _numbersFormat.Value.NumberDecimalSeparator || 
            text == _numbersFormat.Value.PositiveSign + _numbersFormat.Value.NumberDecimalSeparator) 
            return true;
        // Now, lets check, whether text is a valid double 
        bool isValidDouble = StringEx.IsDouble(text);
        // If text is a valid double - we're done 
        if (isValidDouble) 
            return true;
        // Text could be invalid, but we still could accept such input. 
        // For example, we should accepted "1.", because after that user will type 1.12 
        // But we should not accept "..1" 
        int separatorCount = CountOccurances(text, _numbersFormat.Value.NumberDecimalSeparator); 
        // If text is not double and we don't have separator in this text 
        // or if we have more than one separator in this text, than text is invalid 
        if (separatorCount != 1) 
            return false;
        // Lets remove first separator from our input text 
        string textWithoutNumbersSeparator = RemoveFirstOccurrance(text, _numbersFormat.Value.NumberDecimalSeparator);
        // Second corner case: 
        // '.' is also valid text, because .1 is a valid double value and user may try to type this value 
        if (textWithoutNumbersSeparator.IsNullOrEmpty()) 
            return true;
        // Now, textWithoutNumbersSeparator should be valid if text contains only one 
        // numberic separator 
        bool isModifiedTextValid = StringEx.IsDouble(textWithoutNumbersSeparator); 
        return isModifiedTextValid; 
    }
    /// <summary> 
    /// Returns number of occurances of value in text 
    /// </summary> 
    private static int CountOccurances(string text, string value) 
    { 
        string[] subStrings = text.Split(new[] { value }, StringSplitOptions.None); 
        return subStrings.Length - 1;
    }
    /// <summary> 
    /// Removes first occurance of valud from text. 
    /// </summary> 
    private static string RemoveFirstOccurrance(string text, string value) 
    { 
        if (string.IsNullOrEmpty(text)) 
            return String.Empty; 
        if (string.IsNullOrEmpty(value)) 
            return text;
        int idx = text.IndexOf(value, StringComparison.InvariantCulture); 
        if (idx == -1) 
            return text; 
        return text.Remove(idx, value.Length); 
    }
}

注释而不是答案，但是。。。

我要小心验证每个按键上的输入，因为这可能会产生意想不到的后果，并惹恼最终用户。

例如，我记得我对一个日期选择器控件感到恼火，该控件不允许将来的日期，并且被初始化为今天的日期。它在输入日期、月份或年份后进行验证，因此如果不首先更改年份，就不可能输入比当前日期晚的月份/日期。

在双打的情况下，您可能会遇到类似的问题，例如，您提出的验证会阻止用户输入完全有效的值"-1"、".12"、"1e+5"：

-       - invalid
-1      - valid
.       - invalid
.1      - valid
1       - valid
1e      - invalid
1e+     - invalid
1e+5    - valid

我建议在用户离开文本框或通过单击按钮进行显式验证时照常进行验证。

相关文章：