Notifications dans un delegate asynchrone

Soyez le premier à donner votre avis sur cette source.

Vue 6 916 fois - Téléchargée 658 fois

Description

Bonjour,
Pour un projet en développement, j'ai mis au point un delegate asynchrone avec 2 événements de type EventWaitHandle dont l'un informe quand le traitement est terminé et l'autre autorise le traitement suivant.
C'est une classe que j'ai appelé DelegateNotify qui encaspule le delegate et les 2 événements.

Pour illustrer ce delegate, j'ai développé un petit test sympathique et ludique : une télé!
Car une télé a besoin que l'image soit entièrement affichée avant de passer à la suivante.
Mais, ce n'est qu'un petit test alors il n'y a pas de présentateur !
Salut :)

Source / Exemple :


1/ Le delegate:
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
using System.Reflection;
using System.Threading;

namespace notify
{
    public class DelegateNotify
    {
        public delegate void Notify();
        public delegate void AsyncCallback(IAsyncResult ar);
        private EventWaitHandle EventFinished;
        private EventWaitHandle Event;
        private Notify running;
        private AsyncCallback review;

        public DelegateNotify()
        {
            this.Event = new EventWaitHandle(false, EventResetMode.AutoReset);
            this.EventFinished = new EventWaitHandle(false, EventResetMode.AutoReset);
        }

        public void SetFunction(Notify not)
        {
            this.running = not;
        }

        public void SetReview(AsyncCallback callback)
        {
            this.review = callback;
        }

        public void WaitBeforeContinue()
        {
            WaitHandle.WaitAny(new WaitHandle[] { this.Event });
        }

        public void WaitWorkEnding()
        {
            WaitHandle.WaitAny(new WaitHandle[] { this.EventFinished });
        }

        public void NotifyContinue()
        {
            this.Event.Set();
        }

        public void NotifyWorkEnding()
        {
            this.EventFinished.Set();
        }

        public void Invoke()
        {
            this.running.BeginInvoke(new System.AsyncCallback(delegate(IAsyncResult async) {
                if (this.review != null)
                    this.review(async);
            }), null);
        }
    }
}

Conclusion :


Pour résumer, la classe DelegateNotify utilise 1 delegate principal appelé Notify ainsi que 2 EventWaitHandle nommés EventFinished et Event. Il faut appeler d'abord SetFunction avec l'implémentation du delegate puis Invoke.
Ensuite, dans le delegate, on peut appeler NotifyWorkEnding et WaitBeforeContinue.
Dans l'application, on peut appeler WaitWorkEnding et NotifyContinue.
Et voila

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
9
Date d'inscription
samedi 21 mai 2005
Statut
Membre
Dernière intervention
21 octobre 2014

Ok, merci de ta réponse et bonne journée :)
Messages postés
10
Date d'inscription
vendredi 18 avril 2008
Statut
Membre
Dernière intervention
17 juin 2010

D'après les explications que t'as donné dans ton message précédent, je pense que deux ManualResetEvent suffissent largement : un pour notifier que le Thread1 peut continuer et un autre pour notifier que le Thread2 peut continuer.
Messages postés
9
Date d'inscription
samedi 21 mai 2005
Statut
Membre
Dernière intervention
21 octobre 2014

je ne vois pas trop ce que tu entends par avertir de la fin d'exécution d'un thread et la reprise d'un autre thread ?
ici:
- le thread 1 fait son traitement et une fois qu'il a terminé attend d'être notifié pour continuer.
- Le thread 2 attend que la thread 1 ait fini son traitement et une fois que le thread 1 a terminé le thread 2 fait son traitement.
- Une fois que le thread 2 a fait son traitement, le thread 2 peut notifier au thread 1 de continuer.

Comment vois tu les choses avec 1 voir 2 AutoResetEvent ou ManualResetEvent ?
Messages postés
9
Date d'inscription
samedi 21 mai 2005
Statut
Membre
Dernière intervention
21 octobre 2014

bonjour,
Avec les objets EventWaitHandle, c'est déjà un handle.
En revanche, avec un AutoResetEvent, il faut faire truc.Handle.
Messages postés
10
Date d'inscription
vendredi 18 avril 2008
Statut
Membre
Dernière intervention
17 juin 2010

Salut,

belle invention mais ne pense tu pas réinventé la roue en passant à côté des AutoResetEvent et ManualResetEvent qui permettent lorsqu'ils sont combinés avec des threads d'être averti de la fin d'exécution d'un thread et aussi la reprise d'un autre ?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.