Winforms équivalent de javascript setTimeout

Est-il une simple solution/idée/stratégie pour créer un setTimeout fonction équivalente dans une application WinForms. Je suis principalement un développeur web, mais je suis pas sûr de savoir comment j'allais sur ce sujet dans une Application WinForms. En gros, j'ai une zone de texte, et après chaque frappe, je veux exécuter une tâche à remplir une liste (comme un auto-remplir le type de truc) mais vous voulez être en mesure de l'annuler (par exemple clearTimeout) si l'utilisateur conserve la saisie de caractères...

Ma seule supposition est peut-être d'utiliser un BackGroundWorker et de la faire dormir à l'origine, et pendant son sommeil, il peut être annulé, si l'utilisateur arrête la saisie des clés et de la période de sommeil se termine, il va alors et exécute la tâche etc

(je n'ai pas de soins si un exemple est le C# ou Vb.Net)

Javascript du SetTimeout, SetInterval et ClearInterval équivalent en c#

OriginalL'auteur davidsleeps | 2010-12-02

12

Vous pouvez utiliser un Système.Les minuteries.Minuterie: ensemble AutoReset pour faux et usage de Démarrage/Arrêt de méthodes et de créer un gestionnaire pour l'événement Écoulée.

OriginalL'auteur Serguei
27

Je sais que c'est une vieille question, mais une solution alternative serait d'utiliser Task.Delay(delay).ContinueWith((task) => { /* Code */});.

Fil de discussion.Sommeil vs Tâche.Retard?

ou il y a await Task.Delay(delay);

https://social.msdn.microsoft.com/Forums/vstudio/en-US/345f0402-3af0-4f96-a501-073674883ba3/building-an-async-settimeout-function?forum=csharpgeneral

Les choses ont parcouru un long chemin depuis...merci pour l'affichage de la réponse!

OriginalL'auteur Robert
11
```
    public void setTimeout(Action TheAction, int Timeout)
    {
        Thread t = new Thread(
            () =>
            {
                Thread.Sleep(Timeout);
                TheAction.Invoke();
            }
        );
        t.Start();
    }
```
merci de poster une solution élégante
Je ne recommande pas l'utilisation de cette méthode. La création d'un thread juste pour une seule opération? Overkill. Utiliser la classe Timer fourni dans l'autre méthode pour quelque chose de plus à la production digne. Selon cette réponse, 1 MO de mémoire est allouée pour chaque nouveau thread. stackoverflow.com/a/2744464/881111 -- Rappelez-vous, l'OP a dit qu'il allait courir cet après chaque frappe... donc envisager de 1 MO de mémoire ET un nouveau thread pour chaque touche du clavier. Mauvaise idée.
Non seulement une mauvaise idée. Ce qui a probablement des problèmes de concurrence

OriginalL'auteur Rob Hardy

Je peux proposer suivantes

internal class Timeout : System.Timers.Timer
{
    public Timeout (Action action, double delay)
    {
        this.AutoReset = false;
        this.Interval = delay;
        this.Elapsed += (sender, args) => action();
        this.Start();
    }
}
//Example
var timeout = new Timeout(() => {
    Console.WriteLine("init 1");
}, 500);
timeout.Stop();

OriginalL'auteur Oleg

    public void setTimeout(Action act, int timeout)
    {
        Action action = () =>
        {
            Thread.Sleep(Timeout);
            act();
        };

        new Thread(() => Invoke(action)).Start();
    }

Ce travail?

OriginalL'auteur Ahmet Goktas

0

Je vous recommande d'utiliser réactif de programmation pour ce. Voir https://github.com/Reactive-Extensions/Rx.NET pour la Réactif Extensions .NET et http://reactivex.io/, pour l'information générale à propos de Réactif de programmation.

J'ai peur, je ne suis familier avec le JavaScript réactif de bibliothèque, donc je ne peux pas vous donner un C-Sharp exemple, mais en JavaScript, il fallait quelque chose comme ceci:
```
Rx.Observable.fromEvent(..eventdetails..)
    .debounceTime(300)
    .distinctUntilChanged()
    .subscribe(eventHandler);
```
À l'aide d'une installation comme cela, vous pouvez opérateurs de la chaîne à la carte et fusionner toutes sortes d'événements à partir d'une source à un abonné. L'exemple simple ci-dessus réagit à un événement, un keyUp par exemple, et attend jusqu'à ce qu'il n'y a pas de nouveaux keyUp pour 300 ms, puis appelle le gestionnaire d'événements, mais seulement si la nouvelle valeur (après 300ms) est différente de la dernière valeur émise.

OriginalL'auteur Robba

C'est ma façon, l'utilisation de C# 7.0 syntaxe de la fonction.
Certains diffèrent avec js, lors de l'action de délai d'attente exécuter alors peut pas être clair.

internal static class JsStyleTimeout
{
    private static readonly ConcurrentDictionary<int, Thread> InnerDic;

    private static int _handle;

    static JsStyleTimeout()
    {
        InnerDic = new ConcurrentDictionary<int, Thread>();
    }

    public static int Set(Action action, int delayMs)
    {
        var handle = Interlocked.Increment(ref _handle);

        var thread = new Thread(new ThreadStart(delegate
        {
            Thread.Sleep(delayMs);
            InnerDic.TryRemove(handle, out var _);
            Task.Factory.StartNew(action);
        }));
        InnerDic.TryAdd(handle, thread);

        thread.Start();
        return handle;
    }

    public static void Clear(int handle)
    {
        if (InnerDic.TryRemove(handle, out var thread))
            thread.Abort();
    }
}

OriginalL'auteur IlPADlI

Vous devez vous connecter pour publier un commentaire.