C #: déclenchement d'un événement lorsqu'un objet est ajouté à une file d'attente

J'ai besoin d'être en mesure de déclencher un événement chaque fois qu'un objet est ajouté à un Queue<Delegate>.

J'ai créé une nouvelle classe qui étend la classe Queue:

public delegate void ChangedEventHandler(object sender, EventArgs e);

public class QueueWithChange<Delegate> : Queue<Delegate>
{
    public event ChangedEventHandler Changed;

    protected virtual void OnChanged(EventArgs e) {
        if (Changed != null)
        {
            Changed(this, e);
        }
    }
}

Puis attaché à l'événement à partir d'une autre classe, comme tel:

QueueWithChange<TimerDelegate> eventQueue = new QueueWithChange<TimerDelegate>();

//

eventQueue.Changed += new ChangedEventHandler(delegate(object s, EventArgs ex) {
    //This event is not being triggered, so this code is unreachable atm...and that is my problem

    if (eventQueue.Count > 0)
    {
        eventQueue.Dequeue().Invoke(new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(5) });
        actionTimer.Stop();
    }
});

Mais à chaque fois que je mets en file d'attente un objet (eventQueue.Enqueue(something)), le joint de l'événement n'est pas déclenché.

Ce qui me manque ici?

source d'informationauteur Andreas Grech

c#delegates events queue

Si vous voulez dire la non-générique Queue classe, alors vous pouvez simplement remplacer Enqueue:

public override void Enqueue(object obj)
{
    base.Enqueue(obj);
    OnChanged(EventArgs.Empty);
}

Toutefois, si vous voulez dire que le générique Queue<T> classe, puis notez qu'il n'existe pas de méthode virtuelle à remplacer. Vous feriez mieux de encapsuler la file d'attente avec votre propre classe:

(** important edit: suppression de la classe de base!!! **)

class Foo<T>
{
    private readonly Queue<T> queue = new Queue<T>();
    public event EventHandler Changed;
    protected virtual void OnChanged()
    {
        if (Changed != null) Changed(this, EventArgs.Empty);
    }
    public virtual void Enqueue(T item)
    {
        queue.Enqueue(item);
        OnChanged();
    }
    public int Count { get { return queue.Count; } }

    public virtual T Dequeue()
    {
        T item = queue.Dequeue();
        OnChanged();
        return item;        
    }
}

Cependant, en regardant le code, il semble possible que vous êtes en utilisant plusieurs threads ici. Si c'est le cas, envisager une filetée de la file d'attente à la place.

4

Je viens d'écrire sur ce que j'appelle un TriggeredQueue. Il est inspiré de la réponse de Marc Gravel.

Vous pouvez trouver mon post ici: http://joesauve.com/triggeredqueuet

Et l'Essentiel ici: http://gist.github.com/jsauve/b2e8496172fdabd370c4

Il a quatre événements:
- WillEnqueue
- WillDequeue
- DidEnqueue
- DidDequeue
Vous pouvez brancher dans l'un de ces comme suit:
```
YourQueue.WillEnqueue += (sender, e) => {
    //kick off some process
};
YourQueue.DidEnqueue += (sender, e) => {
    //kick off some process
    //e.Item provides access to the enqueued item, if you like
};
YourQueue.WillDequeue += (sender, e) => {
    //kick off some process
};
YourQueue.DidDequeue += (sender, e) => {
    //kick off some process
    //e.Item provides access to the dequeued item, if you like
};
```
Un truc intéressant est que vous pouvez utiliser le DidDequeue méthode pour lancer un processus pour s'assurer que la file d'attente est pleine, en faisant une de demande web ou de charger des données à partir d'un système de fichiers, etc. J'ai utiliser cette classe dans Xamarin applications mobiles pour s'assurer que les données et les images sont pré-en cache afin de fournir une expérience utilisateur des plus douces, au lieu de charger les images APRÈS les avoir faites défiler sur l'écran (comme vous pouvez le voir dans Facebook et d'innombrables autres applications).

essayer

public new void Enqueue(Delegate d)
{
    base.Enqueue(d);
    OnChanged(EventArgs.Empty);
}

0

Vous devez remplacer les mettre en File d'attente, à l'appel OnChanged.

Vous devez vous connecter pour publier un commentaire.