C# Liste aller Instanzen eines Objekts

[Sven L. (sven_rvbg)]

Hallo Zusammen,
ein Programm erstellt nach Bedarf Instanzen von einem Objekt.

ThreadWorker() 
{
if (Bedarf)
     MeinObject mo = new MeinObject();
}

Diese Objekte sind jeweils Teil eines Threads, der im Hindergrund läuft.


Meine Frage wäre gibt es eine Möglichkeit herauszufinden, wieviele 
dieser Objekte erstellt wurden um dann gezielt auf die Objekte zugreifen 
zu können und ggf. ein Objekt zerstören zu können?

Danke!

[Peter II (Gast)]

Bestimmt kommt man über Reflexion und die Runtime irgendwie an so eine 
Liste, aber das einfachste ist die Objekte einfach selber in einer Liste 
abzulegen.

[Matthias S. (matthias_s)]

Vor dem Starten des jeweiligen Threads das Objekt im Hauptthread in eine 
Liste packen? Das dürfte zumindest die unkomplizierteste Lösung sein.

[Sven L. (sven_rvbg)]

Cool, danke... mal wieder zu kompliziert gedacht...

hab mich an das Bsp von MS gehalten und mein Problem damit lösen können:
https://msdn.microsoft.com/de-de/library/6sh2ey19(v=vs.110).aspx

[Florian S. (sevenacids)]

Per Reflection wird das nicht gehen, weil man dadurch nicht auf die 
internen Strukturen der CLR zugreifen kann, diese sind opak. Es können 
im Prinzip nur Typinformationen abgefragt und dynamischer Code 
ausgeführt werden.

Man kann es natürlich mit einer Liste machen, nur hat man dann 
allerdings das Problem, dass wenn man eine Instanz nach der Verwendung 
nicht wieder explizit aus der Liste entfernt durch die Objektreferenz 
ein Speicherleck entsteht - denn solange das Objekt von der Liste 
referenziert wird, kann es nicht vom GC bereinigt werden, auch wenn es 
schon lange nicht mehr benutzt wird. Eine Möglichkeit wäre, IDisposable 
zu implementieren und in der Dispose()-Methode die Instanz explizit 
wieder aus der Liste zu entfernen, aber auch das ist problematisch weil 
der Dispose-Aufruf nicht garantiert werden kann (wenn man z.B. keinen 
using-Block verwendet und den Aufruf vergisst) oder man nicht weiß, ob 
das Objekt an anderer Stelle noch benötigt wird. Höchstens per 
Destruktor (Finalizer), was sich allerdings negativ auf die Performance 
auswirken kann.

Das reine Zählen, wie viele Instanzen eines Objektes erstellt wurden, 
wäre noch relativ simpel über einen Zähler in einem statischen Feld, der 
im Konstruktor inkrementiert wird, zu lösen. Mit dem 
[ThreadStatic]-Attribut wahlweise auch per Thread.

Wenn man schon eine Liste nimmt, dann bitte mit schwachen Referenzen (so 
genannte "Weak List"). Generell sollte man solche Konstrukte eher meiden 
und versuchen die behandelte Problematik anders zu lösen. Vor allem in 
Multi-Thread-Szenarien. Threadübergreifende Objekte, sofern nicht 
immutable, sind immer schwierig zu handhaben. Und List<T> ist auch nicht 
threadsicher!

[C# Entwicker (Gast)]

https://msdn.microsoft.com/en-us/library/dd381779(v=vs.110).aspx

[Florian S. (sevenacids)]

C# Entwicker schrieb:
> https://msdn.microsoft.com/en-us/library/dd381779(...

Schon klar, das ändert aber trotzdem nichts an der Tatsache eines 
möglichen Speicherlecks durch verwaiste Referenzen in der Liste.

Vielleicht habe ich allerdings auch die ursprüngliche Fragestellung 
nicht ganz richtig erfasst...

> Diese Objekte sind jeweils Teil eines Threads, der im Hindergrund läuft."

Tja, ich bin irgendwie automatisch von einer threadübergreifenden Liste 
ausgegangen. Wenn die Liste nun auf einen Thread beschränkt ist, wird 
die Sache natürlich weniger problematisch, dann kann man auch die 
normale Liste nehmen und wenn die am Ende nicht mehr irgendwo 
referenziert wird, ist alles in Butter. :)

[C# Entwicker (Gast)]

https://msdn.microsoft.com/en-us/library/dd381774(v=vs.110).aspx