Kann die Verwendung von Lambda als Event-Handler einen Speicherverlust verursachen?

Question

Sagen wir die folgende Methode haben:

private MyObject foo = new MyObject(); 

// and later in the class 

public void PotentialMemoryLeaker(){ 
    int firedCount = 0; 
    foo.AnEvent += (o,e) => { firedCount++;Console.Write(firedCount);}; 
    foo.MethodThatFiresAnEvent(); 
} 

Wenn die Klasse mit dieser Methode instanziiert wird und die PotentialMemoryLeaker Methode wird mehrmals aufgerufen, tun wir ein Speicherleck?

Gibt es eine Möglichkeit, diesen Lambda-Event-Handler zu lösen, nachdem wir MethodThatFiresAnEvent aufrufen?

Answer 1

Ja, speichern Sie es in eine Variable und haken Sie es aus.

DelegateType evt = (o, e) => { firedCount++; Console.Write(firedCount); }; 
foo.AnEvent += evt; 
foo.MethodThatFiresAnEvent(); 
foo.AnEvent -= evt; 

Und ja, wenn Sie nicht tun, werden Sie Speicherleck, wie Sie jedes Mal eine neue Delegatobjekt anschließen werden. Sie werden dies auch bemerken, weil jedes Mal, wenn Sie diese Methode aufrufen, eine steigende Anzahl von Zeilen an die Konsole übertragen wird (nicht nur eine steigende Zahl), sondern für einen Aufruf von MethodThatFiresAnEvent eine beliebige Anzahl von Elementen einmal für jede angeschlossene anonyme Methode).

Answer 2

Ja, genauso wie normale Ereignishandler Lecks verursachen können. Da das Lambda tatsächlich geändert wird:

someobject.SomeEvent +=() => ...; 
someobject.SomeEvent += delegate() { 
    ... 
}; 

// unhook 
Action del =() => ...; 
someobject.SomeEvent += del; 
someobject.SomeEvent -= del; 

Also im Grunde ist es nur kurze Hand für das, was wir haben in 2.0 all diesen Jahren im Einsatz.

Answer 3

Sie werden nicht nur Speicher verlieren, Sie werden auch Ihr Lambda mehrmals aufgerufen. Jeder Aufruf von 'PotentialMemoryLeaker' fügt der Ereignisliste eine weitere Kopie des Lambda hinzu, und jede Kopie wird aufgerufen, wenn 'AnEvent' ausgelöst wird.

Answer 4

Ihr Beispiel kompiliert nur zu einem Compiler namens private innere Klasse (mit Feld fireCount und eine Compiler-benannte Methode). Jeder Aufruf von PotentialMemoryLeaker erstellt eine neue Instanz der Schließklasse, in der foo einen Verweis über einen Delegaten auf die einzelne Methode behält.

Wenn Sie nicht das gesamte Objekt referenzieren, das PotentialMemoryLeaker besitzt, wird das alles als Müll gesammelt. Andernfalls können Sie entweder foo auf null oder leer foo der Event-Handler-Liste setzen dies durch Schreiben:

foreach (var handler in AnEvent.GetInvocationList()) AnEvent -= handler; 

Natürlich haben Sie Zugriff auf die privaten Mitglieder MyObject Klasse brauchen würde.

Answer 5

Sie können Nun zu erweitern, was here getan wurde Delegierten sicherer zu verwenden (keine Speicherlecks)