Question

C＃中是否有一种方法可以等到用户输入文本框后再输入他们输入的值而没有输入？

稍微修改了这个问题：

好的，我有一个简单的计算器乘以2.

以下是我想要它做的事情：用户在文本框中输入一个1000之类的值，它会自动显示2000.

以下是发生的情况：用户输入1时，它乘以2并输出2.

Answer 1

我现在将“已完成的输入”定义为“用户键入了某些内容但在一段时间后未输入任何内容”。作为一个定义，我编写了一个从TextBox派生的小类，用DelayedTextChanged事件扩展它。我不确保完整且没有bug，但它满足了小型烟雾测试。随意更改和/或使用它。我称之为MyTextBox，因为我现在无法想出一个更好的名字。您可以使用DelayedTextChangedTimeout属性更改等待超时。默认值为10000毫秒（= 10秒）。

public class MyTextBox : TextBox
{
    private Timer m_delayedTextChangedTimer;

    public event EventHandler DelayedTextChanged;

    public MyTextBox() : base() 
    {
        this.DelayedTextChangedTimeout = 10 * 1000; // 10 seconds
    }

    protected override void Dispose(bool disposing)
    {
        if (m_delayedTextChangedTimer != null)
        {
            m_delayedTextChangedTimer.Stop();
            if (disposing)
                m_delayedTextChangedTimer.Dispose();
        }

        base.Dispose(disposing);            
    }

    public int DelayedTextChangedTimeout { get; set; }

    protected virtual void OnDelayedTextChanged(EventArgs e)
    {
        if (this.DelayedTextChanged != null)
            this.DelayedTextChanged(this, e);
    }

    protected override void OnTextChanged(EventArgs e)
    {
        this.InitializeDelayedTextChangedEvent();
        base.OnTextChanged(e);            
    }                

    private void InitializeDelayedTextChangedEvent()
    {
        if (m_delayedTextChangedTimer != null)
            m_delayedTextChangedTimer.Stop();

        if (m_delayedTextChangedTimer == null || m_delayedTextChangedTimer.Interval != this.DelayedTextChangedTimeout)
        {                
            m_delayedTextChangedTimer = new Timer();
            m_delayedTextChangedTimer.Tick += new EventHandler(HandleDelayedTextChangedTimerTick);
            m_delayedTextChangedTimer.Interval = this.DelayedTextChangedTimeout;
        }

        m_delayedTextChangedTimer.Start();
    }

    private void HandleDelayedTextChangedTimerTick(object sender, EventArgs e)
    {
        Timer timer = sender as Timer;
        timer.Stop();

        this.OnDelayedTextChanged(EventArgs.Empty);
    }
}

Answer 2

如果您使用的是WPF和.NET 4.5或更高版本，则在名为＆＃34; Delay＆＃34;的控件的Binding部分上有一个新属性。它定义了更新源之后的时间跨度。

<TextBox Text="{Binding Name, Delay=500}" />

这意味着仅在500毫秒后更新源。据我所知，它在TextBox输入结束后进行了更新。顺便说一句。此属性在其他场景中也很有用，例如。 ListBox等。

Answer 3

另一个简单的解决方案是在表单中添加一个计时器，将Interval属性设置为250，然后使用计时器的tick事件，如下所示：

private void timer1_Tick(object sender, EventArgs e)
{
    timer1.Stop();
    Calculate(); // method to calculate value
}

private void txtNumber_TextChanged(object sender, EventArgs e)
{
    timer1.Stop();
    timer1.Start();
}

Answer 4

您可以处理文本框的LostFocus事件，该事件将在用户每次完成输入时触发并从文本框导航。以下是有关LostFocus的文档：http://msdn.microsoft.com/en-us/library/system.windows.forms.control.lostfocus.aspx

但是，我不确定你到底想要做什么，因为问题不是很明确“完成”的含义。

Answer 5

我面临同样的挑战，这是我的简单方法。这没有问题。

public partial class Form2 : Form
    {
        static int VALIDATION_DELAY = 1500;
        System.Threading.Timer timer = null;
        public Form2()
        {
            InitializeComponent();
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            TextBox origin = sender as TextBox;
            if (!origin.ContainsFocus)
                return;

            DisposeTimer();
            timer = new System.Threading.Timer(TimerElapsed, null, VALIDATION_DELAY, VALIDATION_DELAY);

        }
        private void TimerElapsed(Object obj)
        {
            CheckSyntaxAndReport();
            DisposeTimer();            
        }

        private void DisposeTimer()
        {
            if (timer != null)
            {
                timer.Dispose();
                timer = null;
            }
        }

        private void CheckSyntaxAndReport()
        {            
            this.Invoke(new Action(() => 
            {
                string s = textBox1.Text.ToUpper(); //Do everything on the UI thread itself
                label1.Text = s; 
            }
                ));            
        }
    }

Answer 6

您可以使用文本框onChange()事件。如果在文本框中更改了文本，请检查输入的值是否为数字，并根据其他值计算总值。

Answer 7

在UWP中，我通过进行静态lastTimeOfTyping并检查“TextChanged”事件发生的时间来进行延迟检查。当新的“TextChanged”时间匹配然后执行所需的函数时，它会等待静态lastTimeOfTyping匹配。

    private const int millisecondsToWait = 500;
    private static DateTime s_lastTimeOfTyping;
    private void SearchField_OnTextChanged(object sender, TextChangedEventArgs e)
    {
        var latestTimeOfTyping = DateTime.Now;
        var text = ((TextBox)sender).Text;
        Task.Run(()=>DelayedCheck(latestTimeOfTyping, text));
        s_lastTimeOfTyping = latestTimeOfTyping;
    }

    private async Task DelayedCheck(DateTime latestTimeOfTyping, string text)
    {
        await Task.Delay(millisecondsToWait);
        if (latestTimeOfTyping.Equals(s_lastTimeOfTyping))
        {
            // Execute your function here after last text change
            // Will need to bring back to the UI if doing UI changes
        }
    }

Answer 8

您想要使用Leave或LostFocus事件来处理相关文本框。我假设你使用的是WinForm，即使你没有在你的问题中说明它。

Answer 9

我不知道onChange（）是否仅存在于旧版本的c＃中，但我找不到它！

以下内容适用于检测用户何时点击Enter键，或选中TextBox之外的标签，但仅在更改某些文本后：

    //--- this block deals with user editing the textBoxInputFile --- //
    private Boolean textChanged = false;
    private void textBoxInputFile_TextChanged(object sender, EventArgs e) {
        textChanged = true;
    }
    private void textBoxInputFile_Leave(object sender, EventArgs e) {
        if (textChanged) {
            fileNameChanged();
        }
        textChanged = false;
    }
    private void textBoxInputFile_KeyDown(object sender, KeyEventArgs e) {
        if (textChanged & e.KeyCode == Keys.Enter) {
            fileNameChanged();
        }
        textChanged = false;
    }
    //--- end block  --- //

Answer 10

作为异步扩展方法。改编自Grecon14的答案。

public static class UIExtensionMethods
{
    public static async Task<bool> GetIdle(this TextBox txb)
    {
        string txt = txb.Text;
        await Task.Delay(500);
        return txt == txb.Text;
    }
}

用法：

if (await myTextBox.GetIdle()){
    // typing has stopped, do stuff
}

Answer 11

理想的做法是采用类似esskar的继承解决方案，但它与设计者的搭配效果不佳，因此为了重用我选择的辅助样式：

using System;
using System.Threading;
using System.Windows.Forms;
using Timer = System.Threading.Timer;

    internal class DelayedText : IDisposable
    {
        private readonly EventHandler _onTextChangedDelayed;
        private readonly TextBox _textBox;
        private readonly int _period;
        private Timer _timer;

        public DelayedText(TextBox textBox, EventHandler onTextChangedDelayed, int period = 250)
        {
            _textBox = textBox;
            _onTextChangedDelayed = onTextChangedDelayed;
            _textBox.TextChanged += TextBoxOnTextChanged;
            _period = period;
        }

        public void Dispose()
        {
            _timer?.Dispose();
            _timer = null;
        }

        private void TextBoxOnTextChanged(object sender, EventArgs e)
        {
            Dispose();
            _timer = new Timer(TimerElapsed, null, _period, Timeout.Infinite);
        }

        private void TimerElapsed(object state)
        {
            _onTextChangedDelayed(_textBox, EventArgs.Empty);
        }
    }

用法，形式为构造函数：

InitializeComponent();
...
new DelayedText(txtEdit, txtEdit_OnTextChangedDelayed);

我没有努力，但似乎为我工作。

Answer 12

我想在 Return/Tab 和 LostFocus 上提交一个文本框，所以我使用了这个复杂的解决方案，但它有效。

public static void TextBoxEditCommit(TextBox tb, Action<TextBox>OnEditCommit)
{
    if (OnEditCommit == null) 
            throw new ArgumentException("OnEditCommit delegate is mandatory.");
    //THis delegate fire the OnEditCommit Action
    EventHandler _OnEditCommit = delegate(object sender, EventArgs e) 
            { OnEditCommit(tb); };
    //Edit commit on Enter or Tab
    tb.KeyDown += delegate (object sender, KeyEventArgs e)
    {
        if (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Tab)
        {
            //Temporary remove lostfocus event for avoid double commits
            tb.LostFocus -= _OnEditCommit;
            OnEditCommit(tb);
            tb.LostFocus += _OnEditCommit;
        }
    };
    //Edit commit on LostFocus
    tb.LostFocus += _OnEditCommit;
}

您可以通过以下简单代码使用此事件生成器：

//Check for valid content
UIUtil.TextBoxEditCommit(tbRuleName, (tb) => {
        //Your code here, tb.text is the value collected
            });

Answer 13

我遇到了同样的问题，我认为最简单的解决方案是使用 LostFocus 事件：

xml

<TextBox x:Name="YourTextBox" LostFocus="YourTextBox_LostFocus" />

xaml.cs

private void YourTextBox_LostFocus(object sender, RoutedEventArgs e)
{
    //Your code here
}

Answer 14

最直接的方法。

*。xaml

<TextBox Name="Textbox1"
             TextChanged="Textbox1_TextChanged"/>

*。xaml.cs

using System.Threading.Tasks;

public bool isChanging = false;
async private void Textbox1_TextChanged(object sender,
                                        TextChangedEventArgs e)
    {
        // entry flag
        if (isChanging)
        {
            return;
        }
        isChanging = true;
        await Task.Delay(500);

        // do your stuff here or call a function

        // exit flag
        isChanging = false;
    }

Answer 15

如果用户输入速度很快，并且您希望将计算延迟到停止输入，那么下面的代码可能会有所帮助：

private void valueInput_TextChanged(object sender, EventArgs e)
{
    CalculateAfterStopTyping();   
}

Thread delayedCalculationThread;

int delay = 0;
private void CalculateAfterStopTyping()
{
    delay += 200;
    if (delayedCalculationThread != null && delayedCalculationThread.IsAlive)
        return;

    delayedCalculationThread = new Thread(() =>
    {
        while (delay >= 200)
        {
            delay = delay - 200;
            try
            {
                Thread.Sleep(200);
            }
            catch (Exception) {}
        }
        Invoke(new Action(() =>
        {
            // do your calcualation here...
        }));
    });

    delayedCalculationThread.Start();
}

Answer 16

我的一位同事提出了使用Rx和事件限制的解决方案：

var FindDelay = 500;//milliseconds
//textBox is your text box element
Observable.FromEventPattern<EventArgs>(textBox, "TextChanged")
    .Select(ea => ((TextBox) ea.Sender).Text)
    .DistinctUntilChanged()
    .Throttle(TimeSpan.FromMilliseconds(FindDelay))
    .Subscribe(text => { 
        //your handler here 
    });

Answer 17

如果您根据类似按键的按键触发事件或返回该怎么办？

C＃等待用户在文本框中完成输入

17 个答案: