.net-Textbox control-attendre que l'utilisateur ait terminé de taper

pour ceux qui ont besoin de quelque chose comme ça dans .NET 2.0, ici j'ai fait un contrôle qui dérive de TextBox et utilise la même approche.. Espérons que cette aide

public partial class TextBox : System.Windows.Forms.TextBox
{

    private ManualResetEvent _delayMSE;
    public event EventHandler OnUserStopTyping;
    private delegate bool TestTimeout();

    public TextBox()
    {
        _delayMSE = new ManualResetEvent(false);
        this.TextChanged += new EventHandler(TextBox_TextChanged);
    }

    void TextBox_TextChanged(object sender, EventArgs e)
    {


        _delayMSE.Set();
        Thread.Sleep(20);
        _delayMSE.Reset();

        TestTimeout tester = new TestTimeout(TBDelay);
        tester.BeginInvoke(new AsyncCallback(Test), tester);

    }


    private void Test(IAsyncResult pResult)
    { 
        bool timedOut = (bool)((TestTimeout)pResult.AsyncState).EndInvoke(pResult);
        if (timedOut)
        {
            if (OnUserStopTyping != null)
                OnUserStopTyping(this, null);
        }
    }

    private bool TBDelay()
    { 
        return !_delayMSE.WaitOne(500, false); 
    }

}

J'ai fini par essayer la réponse de Scott Weinstein bien que cela nécessitait des connaissances plus approfondies sur le threading, les délégués et la syntaxe lambda de base. Et cela a fonctionné assez bien. Sa réponse originale n'était pas du pur copier-coller, donc j'ai dû jouer pour que ça marche.

j'ai ajouté très peu de temps au Thread.Dormir, depuis que j'ai remarqué la méthode invoke peut se produire deux fois si l'utilisateur tape vraiment rapidement, mais avec un petit délai aléatoire entre certaines des touches. Vous devez également ajouter une référence à Montage de la base de fenêtre pour L'utilisation du répartiteur.

j'utilise 1,5 secondes pour attendre que l'utilisateur tape.

    // use manual reset event to Q up waiting threads.
    // each new text changed event clears the Q
    // only the last changed will hit the timeout, triggering the action
    private ManualResetEvent _delayMSE;
    private Func<bool> TBDelay;
    private delegate void ActionToRunWhenUserStopstyping();

    public Form1()
    {
        InitializeComponent();

        _delayMSE = new ManualResetEvent(false);
        TBDelay = () => !_delayMSE.WaitOne(1500, false);
    }

    private void textBox1_TextChanged(object sender, EventArgs e)
    {
        _delayMSE.Set(); 

        // open the ResetEvent gate, to discard these delays    
        Thread.Sleep(20);
        // let all pending through the gate    
        _delayMSE.Reset();
        // close the gate
        TBDelay.BeginInvoke(res =>    
        {        
            // callback code        
            // check how we exited, via timeout or signal.        
            bool timedOut = TBDelay.EndInvoke(res);
            if (timedOut)
                Dispatcher.CurrentDispatcher.Invoke(
                    new ActionToRunWhenUserStopstyping(DoWhatEverYouNeed), 
                    DispatcherPriority.Input);
        }, null);
    }

    private void DoWhatEverYouNeed()
    {
        MessageBox.Show(textBox1.Text);
    }

cela dépend de ce que vous entendez par "fait de taper."Il y a un événement pour vous faire savoir quand l'Utilisateur a quitté le foyer de ce contrôle particulier. De plus, il y a un changement même qui vous indique quand le texte change. Ce que vous pourriez faire, c'est piéger deux choses:

1) le foyer Perdu

2) Chaque fois que l'utilisateur modifie le texte, démarrer un compte à rebours de 20 secondes, et si l'utilisateur est effectué dans ce délai, l'utilisateur est "fait" taper. C'est-à-dire si l'utilisateur n'a rien fait ce temps suppose alors que l'utilisateur est " fait."

si l'un ou l'autre de ces deux événements se produit alors que l'utilisateur est fait, assurez-vous d'arrêter et de redémarrer le minuteur de manière appropriée. Évidemment, vous pouvez modifier le délai d'attente.

tout dépend de la façon dont vous souhaitez définir.

l'approche que j'ai utilisée avec succès dans le passé utilise un événement de réinitialisation manuelle et des invocations asynchrones pour détecter lorsque l'Utilisateur a cessé de taper. Le code ressemble à quelque chose comme ceci

// use manual reset event to Q up waiting threads.
// each new text changed event clears the Q
// only the last changed will hit the timeout, triggering the action
private ManualResetEvent _delayMSE;
private Func<bool> TBDelay = () => !_delayMSE.WaitOne(600, false);
private void TextBox_TextChanged(object sender, TextChangedEventArgs e)
{
    SendOrPostCallback ActionToRunWhenUserStopsTyping = o =>
    {
        // ...
    };

    _delayMSE.Set(); // open the ResetEvent gate, to discard these delays
    Thread.Sleep(0); // let all pending through the gate
    _delaySearchMSE.Reset(); // close the gate
    TBDelay.BeginInvoke(res =>
    {
        // callback code
        // check how we exited, via timeout or signal.
        bool timedOut = TBDelay.EndInvoke(res);
        if (timedOut)
            Dispatcher.Invoke(DispatcherPriority.Input, 
                            ActionToRunWhenUserStopstyping,null);
    }, null);
}