Środki ostrożności, które należy podjąć, aby zapobiec wyciekom pamięci z powodu dodanych uchwytów zdarzeń.

Question

Mam zamiar utworzyć GUI, który będzie dynamicznie tworzył zestawy kontrolek z przypisanymi im zdarzeniami. Będę musiał dodać i usunąć te kontrolki w czasie wykonywania. Będzie to wyglądać tak:

FlowLayoutPanel.Controls.Clear(); 
<< add new controls, assigning Click events with += >> 

Słyszałem, że przypisywanie obsługi zdarzeń z + = może spowodować wycieki pamięci (więcej specificly, pamięć nie zostanie zwolniona dopóki aplikacja nie zakończy działania). Chcę tego uniknąć. Wiem, że mogę napisać kilka funkcji, takich jak tutaj How to remove all event handlers from a control, aby znaleźć wszystkie programy do obsługi zdarzeń i je usunąć, ale wygląda to bardzo skomplikowanie.

Czy istnieje inny sposób? Czy wywołanie Dispose help usuwa te procedury obsługi zdarzeń? Czy potrafisz niszczyć obiekty, aby wymusić ich pamięć, tak jak w C/C++?

Dzięki!

PS: Problem polega na tym, że nie wiem, co wydarzenie się rozłączy. Stworzę wiele etykiet i dodaję do nich różne rodzaje zdarzeń onclick. Kiedy nadszedł czas czyszczenia panelu układu przepływu, nie ma możliwości sprawdzenia, który program obsługi zdarzenia został dołączony do której etykiety.

To jest przykładowy kod (_flowLP to FlowLayoutPanel) - ta funkcja Refresh() jest uruchamiana wiele razy przed zakończeniem aplikacji.

private void Refresh() 
    { 
     Label l; 
     Random rnd = new Random(); 

     // What code should i add here to prevent memory leaks 
     _flowLP.Controls.Clear(); 

     l = new Label(); 
     l.Text = "1"; 
     if (rnd.Next(3) == 0) l.Click += Method1; 
     if (rnd.Next(3) == 0) l.Click += Method2; 
     if (rnd.Next(3) == 0) l.Click += Method3; 
     _flowLP.Controls.Add(l); 

     l = new Label(); 
     l.Text = "2"; 
     if (rnd.Next(3) == 0) l.Click += Method1; 
     if (rnd.Next(3) == 0) l.Click += Method2; 
     if (rnd.Next(3) == 0) l.Click += Method3; 
     _flowLP.Controls.Add(l); 

     l = new Label(); 
     l.Text = "3"; 
     if (rnd.Next(3) == 0) l.Click += Method1; 
     if (rnd.Next(3) == 0) l.Click += Method2; 
     if (rnd.Next(3) == 0) l.Click += Method3; 
     _flowLP.Controls.Add(l); 

     l = new Label(); 
     l.Text = "4"; 
     if (rnd.Next(3) == 0) l.Click += Method1; 
     if (rnd.Next(3) == 0) l.Click += Method2; 
     if (rnd.Next(3) == 0) l.Click += Method3; 
     _flowLP.Controls.Add(l); 

     l = new Label(); 
     l.Text = "5"; 
     if (rnd.Next(3) == 0) l.Click += Method1; 
     if (rnd.Next(3) == 0) l.Click += Method2; 
     if (rnd.Next(3) == 0) l.Click += Method3; 
     _flowLP.Controls.Add(l); 

     l = new Label(); 
     l.Text = "6"; 
     if (rnd.Next(3) == 0) l.Click += Method1; 
     if (rnd.Next(3) == 0) l.Click += Method2; 
     if (rnd.Next(3) == 0) l.Click += Method3; 
     _flowLP.Controls.Add(l); 
    } 

Answer 1

to głównie będzie to zmartwienie po podłączeniu krótszy przeżyte zdarzenia do konsumenta dłużej żył producenta zdarzeń. Jeśli mają podobne życie lub są przeciwieństwem tego, co opisałem, to nie problem.

W przypadku, gdy się o to martwisz, po prostu użyj = =, aby odłączyć się od wydarzenia. To usuwa odniesienie utworzone przez załącznik i pomaga uniknąć tego rodzaju problemów z pamięcią.

Edycja: Ponieważ komentarze stają się coraz dłuższe, zamieszczę tutaj kilka uwag. Gdy dołączasz do wydarzenia, wiesz, co robisz, gdy wiesz, kim jest dostawca wydarzeń. Na przykład, jeśli masz klasę Zegara ze zdarzeniem StrikesMidnight i subskrybujesz to wydarzenie z klasy o nazwie Bedtime, rzeczywistą mechaniką Bedtime mówiąc: clock.StrikesMidnight += this.HandleMidnight; jest to, że przypisujesz zegarowi odniesienie do siebie. To tak, jakby Clock miał właściwość obiektu i powiedziałeś, że w przypadku, gdy klasa Bedtime jest krótkotrwała i wykracza poza zakres, Bedtime pojawia się, zawiesza odniesienie do siebie na Clock, a następnie idzie poza zakresem. Problem polega na tym, że zegar nadal ma do niego odniesienie, więc nawet jeśli jest poza zakresem, Garbage Collector nie będzie zbierać czasu na dobranoc.

....

To jest tło. W twoim przypadku tworzysz etykietę i dołączasz do niej odnośnik do niej (za pośrednictwem twoich programów obsługi "MethodX"). Po wywołaniu odświeżania wyczyścisz listę etykiet (co oznacza, że ​​wykraczają poza zakres). Wykraczają one poza zakres i mają odwołania do twojej klasy za pośrednictwem jej obsługi metod MethodX, ale co z tego? Ich posiadanie referencji nie przeszkadza im uzyskać GC. Nikt nie odwołuje się do nich w twoim kodzie, więc GC wykona na nich pracę i nie wycieknie ci pamięć.

Answer 2

Wszystkie elementy sterujące powinny zostać oczyszczone przez pojemnik na śmieci, o ile wyrzuca się formularz zawierający.

Subskrybowanie zdarzenia na elementach sterujących nie spowoduje utrzymania kontroli przy życiu, ponieważ element sterujący ma odniesienie do elementu przekazującego operację; delegat nie ma odniesienia do kontroli.

Sytuacja, w której subskrypcja zdarzenia uniemożliwi wyczyszczenie kontrolki, jest przypadkiem, w którym jakiś kod w formancie subskrybuje zdarzenie poza wystąpieniem formularza, w którym jest zawarty. Na przykład, jeśli niestandardowe pole kombi subskrybuje zdarzenie klasy statycznej, aby kontrolka wiedziała, kiedy należy zaktualizować listę opcji. Jeśli kontrola niestandardowa nie rozprzęgnie tego zdarzenia, będzie się do niego odwoływał rejestr zdarzeń klasy statycznej na czas trwania aplikacji. Ponieważ kontrolka będzie miała odniesienie do swojego kontenera (i tak dalej), cały formularz prawdopodobnie pozostanie w pamięci. W takich przypadkach kontrola powinna rozpakować zdarzenie w jego metodzie Dispose. Subskrybowanie zdarzeń na klasach statycznych lub klasach o długiej żywotności powinno zawsze wywoływać czerwoną flagę i być jawnie niezwiane, gdy nie jest już potrzebne.

W formularzach, o ile wszystkie zdarzenia są połączone z metodami instancji w klasie formularza lub obiektach, których zasięg jest kontrolowany przez instancję formularza, elementy sterujące zostaną oczyszczone, gdy wykres obiektu, w którym znajduje się formularz rootowanie wykracza poza zakres. Tylko uważaj, aby klasy zewnętrzne nie zawierały odniesienia do formularza, gdy nie są już potrzebne.

Answer 3

Moja pierwsza sugestia to nie wstępna optymalizacja. Upewnij się, że jest to problem, zanim spróbujesz go rozwiązać.

W odniesieniu do Dispose(): utylizacja powinna być TYLKO używana w celu uwolnienia niezarządzanych zasobów, zanim obiekt zostanie zebrany. Aby uzyskać więcej informacji, patrz http://msdn.microsoft.com/en-us/library/system.idisposable.aspx.

Aby uniemożliwić programom obsługi przetwarzanie odwołań do elementów sterujących, należy zrezygnować z subskrypcji wszystkich programów obsługi zdarzeń, które subskrybują podczas tworzenia. WSKAZ :WKA: Jeśli dodajesz programy do obsługi zdarzeń za pośrednictwem interfejsu GUI, zbadaj automatycznie wygenerowany kod, aby zobaczyć, czego potrzebujesz, aby anulować subskrypcję przed wywołaniem FlowLayoutPanel.Controls.Clear(). Czystym (-a?) Sposobem na zrobienie tego byłoby utworzenie własnej kontroli, która dziedziczy po pożądanym sterowaniu i dodaje metodę "Oczyszczania()", która wypisuje się z jakiejkolwiek obsługi zdarzeń, która została zasubskrybowana (powinieneś wiedzieć, które zdarzenie obsługi zostały zasubskrybowane - albo dlatego, że napisałeś kod, albo został on wygenerowany dla ciebie).