Réinitialiser Le Système.Les minuteries.À rebours pour éviter événement Écoulé

Vous pouvez utiliser le Stop fonction immédiatement suivi par le Start la fonction "redémarrage" de la minuterie. L'aide que vous pouvez créer le Timer lorsque la classe est d'abord créé, le fil de l'événement Écoulé à l'époque, et puis ne rien faire, mais l'appel de ces deux méthodes lorsqu'un élément est ajouté. Il va démarrer ou redémarrer la minuterie. Noter que l'appel Stop sur une minuterie qui n'a pas encore été commencé juste ne fait rien, il ne lance pas d'exception ou de causer d'autres problèmes.

public class Foo
{
    public static List<string> list;
    public static Timer timer;
    static Foo()
    {
        list = new List<string>();
        timer = new Timer(10000);
        timer.Enabled = true;
        timer.AutoReset = false;
        timer.Elapsed += SendToServer;
    }

    public static void Log(string value)
    {
        list.Add(value);
        timer.Stop();
        timer.Start();
    }

    static void SendToServer(object sender, ElapsedEventArgs e)
    {
        //TODO send data to server

        //AutoReset is false, so neither of these are needed
        //timer.Enabled = false;
        //timer.Stop();
    }
}

Note que, plutôt que d'utiliser un List il est très possible que vous souhaitez utiliser un BlockingCollection<string> à la place. Cela a plusieurs avantages. Tout d'abord, le Log méthodes de travail si on l'appelle en même temps à partir de plusieurs threads; est simultané de plusieurs journaux pourraient briser la liste. Cela signifie également que SendToServer pouvez prendre tous les éléments de la file d'attente en même temps que de nouveaux éléments sont ajoutés. Si vous utilisez un List vous aurez besoin de lock tous les accès à la liste (ce qui pourrait ne pas être un problème, mais n'est pas aussi simple).

OriginalL'auteur Servy

Ce que vous êtes à la mise en œuvre est totalement de mauvaise façon de faire. Jetez un oeil à la consommation producteur modèle:

http://msdn.microsoft.com/en-us/library/hh228601.aspx

Ce que vous essayez de faire est très communément appelé le Consommateur/Producteur de flux de données modèle. Essentiellement, vous avez quelque chose de la génération d'une liste de données qui est envoyé quelque part, plutôt que de l'envoyer à chaque fois qu'un élément est ajouté à la liste que vous voulez pour les envoyer dans des groupes.. Si vous avez un producteur (le code en mettant l'envoi de données) et un consommateur (le code de l'envoi des données).

En général, ce problème est résolu en créant un thread qui regarde la liste (généralement une file d'attente) et envoie les données à régulièrement des intervalles, la meilleure façon de le faire est d'utiliser un EventWaitHandle.

Ici est très simplifié le code comme un exemple

    class ServerStuff
{
    public void Init()
    {
        datatosend = new List<string>();
                    exitrequest = new EventWaitHandle(false, EventResetMode.ManualReset); //This wait handle will signal the consumer thread to exit
        Thread t = new Thread(new ThreadStart(_RunThread));
        t.Start(); //Start the consumer thread...
    }

    public void Stop()
    {
        exitrequest.Set();
    }

    List<string> datatosend;
    EventWaitHandle exitrequest;

    public void AddItem(string item)
    {
        lock (((ICollection)datatosend).SyncRoot)
            datatosend.Add(item);
    }

    private void RunThread()
    {
        while (exitrequest.WaitOne(10 * 1000)) //wait 10 seconds between sending data, or wake up immediatly to exit request
        {
            string[] tosend;
            lock (((ICollection)datatosend).SyncRoot)
            {
                tosend = datatosend.ToArray();
                datatosend.Clear();
            }

            //Send the data to Sever here...

        }
    }
}

OriginalL'auteur Matthew Sanford