C# - das hinzufügen und entfernen von Ereignissen aus einem timer

Bin ich versucht, hinzufügen und entfernen von Ereignissen aus einem timer, und ich habe den folgenden code:

Timer myTimer = new Timer(); //Windows.Forms Timer

public void addEvent(MyDelegate ev)
{
    myTimer.Tick += new EventHandler(ev);
}

public void removeEvent(MyDelegate ev)
{
    myTimer.Tick -= new EventHandler(ev);
}

Ich weiß nicht, Wenn ich irgendetwas dummes versuchen, die add-und remove-Delegierten in dieser Weise, ich bin in der Lage, die Delegierten und Sie zu Feuer, wie erwartet. Jedoch wenn ich versuche zu löschen, die Ereignisse, die Sie weiterhin Feuer auf Timer Tick.

Kann jemand sehen, alles, was offensichtlich falsch ist?

Könnten Sie zeigen die Definition der MyDelegate und erklären, warum es da ist?

InformationsquelleAutor TK. | 2009-02-16

c#event-handling

9

Ich glaube, dass dieser code:
```
myTimer.Tick -= new EventHandler(ev);
```
erzeugt eine neue Event-Handler-Objekt. Es wird nie entfernen Sie eine vorhandene Event-Handler. Um die Funktionalität, die Sie möchten, sollten Sie die übergabe in EventHandlers, nicht MyDelegates, um die add-und remove-Methoden:
```
Timer myTimer = new Timer(); //Windows.Forms Timer

public void addEvent(EventHandler ev)
{
    myTimer.Tick += ev;
}

public void removeEvent(EventHandler ev)
{
    myTimer.Tick -= ev;
}
```
Den aufrufenden code haben, um zu verfolgen die Event-Handler Hinzugefügt, so dass es passieren kann in der gleichen Event-Handler-Objekt, wenn es Zeit ist, zu kündigen.
- Der code funktioniert so wie Sie ist - keine Notwendigkeit für den aufrufenden code, um eine Liste der Event-Handler. Die backingstore der Veranstaltung wird der Blick für den eigentlichen Delegaten und löschen Sie die proprt ivocationItem. Sie können rufen Sie removeEvent(MyTickHandler);
- Ich wusste, dass ich mit einem Programmierer-block-moment! Sie sind richtig im Ausspruch, dass die Verwendung von Event-Handler anstelle von Delegierten arbeiten. Vielen Dank für Ihre Hilfe!
InformationsquelleAutor atoumey
3

Dem ersten code funktioniert gut, solange die MyDelegate 'ev' übergeben addEvent und removeEvent ist die gleiche Objekt-Instanz (Zum Beispiel, wenn es eine Klasse-level - MyDelegate Feld enthält die Instanz oder, wenn Sie Folgen Sie den Rat von mehreren anderen hier und halten die MyDelegate Objekt(E) in einem Wörterbuch).

Ich vermute, das problem ist, dass der code ruft addEvent und removeEvent ist vorbei neue MyDelegate Instanzen verweisen auf einige handler-Methode, etwa so:
```
addEvent(new MyDelegate(this.HandlerMethod));
//... do some stuff
removeEvent(new MyDelegate(this.HandlerMethod));
```
In diesem Fall addEvent und removeEvent erstellen EventHandler Delegierte, die aus unterschiedlichen Methode-Adressen auch dann, wenn diese Delegierten wiederum verweisen auf die gleiche Methode (this.HandlerMethod). Dies ist, weil die EventHandler Delegierten, dass add und remove erstellen, zeigen Sie auf die MyDelegate.Invoke() - Methode auf verschiedenen MyDelegate Instanzen, anstatt direkt an die Adresse der this.HandlerMethod.
- Hinzufügen zu jester ' s Verdacht, dies kann auch auftreten, wenn der Anrufer einfach übergibt den Namen der Methode entspricht der delegate-Signatur, z.B., addEvent(dies.MyCallback);. In diesem Fall, wird der Delegat wird implizit erstellt, was zu dem problem beschrieben.
InformationsquelleAutor Jeff Sternal

Dein problem kommt von helper-Methoden, dies zu tun. Ohne Sie, es funktioniert wie erwartet, das Sie es nicht wissen, was zu trennen.

Dieses Problem zu beheben, müssen Sie halten ein dictionary mit dem Wert wird der Event-Handler erstellt, die in die hook-Methode, so dass Sie können entfernen Sie den Wert später.

Etwas wie:

var handlers = new Dictionary<MyDelegate, EventHandler>();

public void addEvent(MyDelegate ev)
{
    var handler = new EventHandler(ev);
    handlers.Add(ev, handler);
    myTimer.Tick += handler;
}

public void removeEvent(MyDelegate ev)
{
    myTimer.Tick -= handlers[ev];
}

Sollten Sie die entsprechenden prüft, ob das element vorhanden ist.

Könnte man auch ändern Sie Ihre parameter-Typ, und es funktioniert wie erwartet.

public void addEvent(EventHandler ev)
{
    myTimer.Tick += ev;
}

public void removeEvent(EventHandler ev)
{
    myTimer.Tick -= ev;
}

addEvent(new EventHandler(...));
removeEvent(new EventHandler(...));

InformationsquelleAutor Samuel

1

Sollten Sie nur in der Lage, sich durch verweisen auf den Namen Ihres noch-handling-Methode etwa so:
```
public void removeEvent(MyDelegate ev)
{
    myTimer.Tick -= ev as EventHandler;
}
```
- Leider führt dies zu einem compiler-Fehler "kann Nicht implizit konvertiert Typ 'myDelegate' zu 'System.EventHandler'"
- Das würde keinen Unterschied machen. Wenn Sie weglassen die new EventHandler(...) oder ähnliche Konstruktoren, Sie werden Hinzugefügt, wenn Sie kompilieren.
- Können, Sie warf es obwohl?
InformationsquelleAutor Factor Mystic
0

Beim hinzufügen und entfernen von Ereignis-Handler erstellen Sie eine neue wrapper für Ihre Delegierten jeder Zeit. Also in deinem remove-Methode, es zu entfernen versuchen eine neue - Event-Handler-Objekt, das wurde nie aufgenommen, wie ein listener für das Ereignis in den ersten Platz.

Wenn Sie möchten, um mit dieser Art von setup, könnte man vielleicht kleben Sie Ihr Event in ein Wörterbuch. In die addEvent-Methode, halten Sie Ihre neu erstellte Event-Handler in Ihrem Wörterbuch, und in der removeEvent Methode, ziehen Sie die Event-Handler aus dem Wörterbuch und zu entfernen, dass anstelle der Instanziierung einer neuen.

InformationsquelleAutor John Conrad
0

Ich weiß nicht, was du falsch machst, aber die übliche Vorgehensweise, die ich benutzen würde für Timer wäre zu abonnieren Tick Ereignis, und deaktivieren Sie den Timer, wenn Sie nicht wollen, zu erhalten, die Ereignisse zu re-aktivieren, wenn Sie tun.

Kann dir nicht helfen, wenn Sie mehr als ein event-handler Anschluss an die Veranstaltung, aber hoffentlich von einigem nutzen.

InformationsquelleAutor Sam Meldrum

Sollte dies funktionieren:

private void timer_Tick(object sender, EventArgs e)
{
    try
    {
        //Disallow re-entry
        timer.Tick -= timer_Tick;
        . . .
    }
    finally
    {
        timer.Tick += timer_Tick;
    }
}

InformationsquelleAutor B. Clay Shannon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.