强制延迟 textbox_textchanged

Question

I have a barcode scanner that emulates keyboard entry. I'm using it to enter ISBN numbers into a textbox, which then performs a search for that title. I need the textbox method to wait for wither a 10 or 13 character entry before doing anything, however I'm not sure how to go about doing it.

So far, I have the following:

private void scanBox_TextChanged(object sender, EventArgs e)
        {

            if (scanBox.Text.Length == 10)
            {
                getRecord10();
            }
            else if (scanBox.Text.Length == 13)
            {
                getRecord13();
            }
            else
            {
                MessageBox.Show("Not in directory", "Error");
            }
        }

I'm considering some sort of timer implementation to hold off on that last condition, but what I really need is for the method to wait for either 10 or 13 digits. The barcode scanner emulates individual keys being pressed, which is why it is currently failing.

Answer 1

You can use Timer (or DispatcherTimer in WPF). This sample app updates window's title 300ms after the last keystroke.

    System.Windows.Forms.Timer _typingTimer; // WinForms
    // System.Windows.Threading.DispatcherTimer _typingTimer; // WPF

    public MainWindow()
    {
        InitializeComponent();
    }

    private void scanBox_TextChanged(object sender, EventArgs e)
    {
        if (_typingTimer == null)
        {
            /* WinForms: */
            _typingTimer = new Timer();
            _typingTimer.Interval = 300;
            /* WPF: 
            _typingTimer = new DispatcherTimer();
            _typingTimer.Interval = TimeSpan.FromMilliseconds(300);
            */

            _typingTimer.Tick += new EventHandler(this.handleTypingTimerTimeout);
        }
        _typingTimer.Stop(); // Resets the timer
        _typingTimer.Tag = (sender as TextBox).Text; // This should be done with EventArgs
        _typingTimer.Start(); 
    }

    private void handleTypingTimerTimeout(object sender, EventArgs e)
    {
        var timer = sender as Timer; // WinForms
        // var timer = sender as DispatcherTimer; // WPF
        if (timer == null)
        {
            return;
        }

        // Testing - updates window title
        var isbn = timer.Tag.ToString();
        windowFrame.Text = isbn; // WinForms
        // windowFrame.Title = isbn; // WPF

        // The timer must be stopped! We want to act only once per keystroke.
        timer.Stop();
    }

Parts of code are taken from the Roslyn syntax visualizer

Answer 2

I propose a solution usingMicrosoft Reactive Extensions which are available as a nuget package.

Reactive Extensions is a library to compose asynchronous and event-based programs using observable collections and LINQ-style query operators.

If you use the RX extensions your problem can be solved with just two lines of code:

Sign up for an event: here with count == 10

    IObservable<string> textChangedObservable =
    Observable.FromEventPattern(textBox1, "TextChanged")
    .Select(evt => ((TextBox)evt.Sender).Text).Where(x => x.Length == 10);

Subscribe to the Event:

    textChangedObservable.Subscribe(e => MessageBox.Show(e));

Answer 3

Check if this helps.

    private System.Timers.Timer timer;

    private void scanBox_TextChanged(object sender, EventArgs e)
    {
        if (scanBox.Text.Length == 10)
        {
            //wait for 10 chars and then set the timer
            timer = new System.Timers.Timer(2000); //adjust time based on time required to enter the last 3 chars 
            timer.Elapsed += OnTimedEvent;
            timer.Enabled = true;
        }

    }

    private void OnTimedEvent(Object source, ElapsedEventArgs e)
    {
        timer.Enabled = false;

        if (scanBox.Text.Length == 10)
        {
            getRecord10();                
        }
        else if (scanBox.Text.Length == 13)
        {
            getRecord13();
        }
        else
        {
            MessageBox.Show("Not in directory", "Error");
        }
    }

Answer 4

I went for the timer solution and created a simple class to wrap it up a bit more neatly. The TypingFinished event is then accessed from the Form if it is needed.

The TextChanged event is wrapped inside the HandleCreated event to prevent it from being invoked when Application Settings are being set to the textbox.

Settings.Default.Save is called because it is always true for me, but could just as well be put in the TypingFinished event.

using YourApp.Properties;
using System;
using System.Windows.Forms;

namespace YourApp.Controls
{
    public partial class TypeDelayTextBox : TextBox
    {
        public TypeDelayTextBox()
        {
            InitializeComponent();

            this.HandleCreated += (senderX, argsX) => { this.TextChanged += OnTextChanged; };
        }

        private void OnTextChanged(object sender, EventArgs args)
        {
            _timer.Enabled = true;
            _timer.Stop();
            _timer.Start();
        }

        private void _timer_Tick(object sender, EventArgs e)
        {
            _timer.Stop();
            Settings.Default.Save();
            OnTypingFinished();
        }

        public event EventHandler TypingFinished;

        protected virtual void OnTypingFinished()
        {
            TypingFinished?.Invoke(this, EventArgs.Empty);
        }
    }
}

Designer code:

namespace YourApp.Controls
{
    partial class TypeDelayTextBox
    {
        /// <summary> 
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary> 
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this._timer = new System.Windows.Forms.Timer(this.components);
            this.SuspendLayout();
            // 
            // _timer
            // 
            this._timer.Interval = 3000;
            this._timer.Tick += new System.EventHandler(this._timer_Tick);
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.Timer _timer;
    }
}

Answer 5

Here is a solution to pass an action to be invoked after the timer period. Thanks to Amadeusz Wieczorek asnwer:

    private Timer _typingTimer;

    private void textBox1_TextChanged(object sender, EventArgs e)
    {
        CheckTimer(() => { label1.Text = (sender as TextBox)?.Text; });
    }

    private void CheckTimer(Action act)
    {
        if (_typingTimer == null)
        {
            _typingTimer = new Timer { Interval = 350 };
            _typingTimer.Tick += (sender, args) =>
            {
                if (!(sender is Timer timer))
                    return;
                act?.Invoke();
                timer.Stop();
            };
        }
        _typingTimer.Stop();
        _typingTimer.Start();
    }