Handles zählen

Xatian

Hallihallo!

Gibt es einen Möglichkeit, die Anzahl der TackingHandles die ein Object referenzieren zu zählen??

Also alla:

void Test (Object^ object)
{
   Int32 iRef = ReferenzenZählen (object);
   Console::WriteLine (iRef); //2
}

int main (array<String^>^ args)
{
    Object^ object = gcnew Object;

    Int32 iRef = ReferenzenZählen (object);
    Console::WriteLine (iRef); //1

    Test (object);

    iRef = ReferenzenZählen();
    Console::WriteLine (iRef); //1

    return 0;
}

Gibt es da ne Möglichkeit das so zu machen?

Im Prinzip will ich ein Object mehreren Threads übergeben, die ich zwar jetzt implementieren kann (Ich kann noch entscheiden, was der Thread mit dem Object machen soll ... also hab alle Möglichkeiten offen), zur Laufzeit dann aber nicht steuern kann (sprich keine Synchronisation oder sonstiges).
Ich will jetzt aber wissen, wann der Thread das Object nicht mehr braucht.
Eine Möglichkeit wäre innerhalb des Objectes einen Referenzenzähler zu implementieren (so IUnknown mäßig), aber ich dachte vielleicht gibt es auch einen Möglichkeit einfach die Handles zu zählen, oder vielleicht weiß jemand von euch eine Möglichkeit das in C++/CLI "elegant" zu implementieren.

Danke

Xatian

Niemald weiß das??

Vielleicht hat jemand wenigstens einen Idee, ob es überhaupt möglich ist, mit Hilfe der CLI - Klassenbibliotek die Anzahl der Handles die ein Object referenzieren rauszufinden.
Irgendwie denke ich gehts schon ... die GC braucht die Info ja auch oder?

MfG

simon.gysi

Ich würde diese beiden Aufgaben (deine eigene Verwendungs- Verwaltung und die der CLR) strikt getrennt lassen. Auch wenn es gehen würde, was ich jedoch nicht glaube.

Daue deine eigene Verwaltung ein oder überdenke das Design.

Simon

Jochen Kalmbach

Was willst Du denn genau machen? Warum brauchst Du das?

Xatian

Hmmm ... das ist schwer zu erklären ^^

Ich entwickle als Diplomarbeit ein System, welches Software-Module miteinander verbindet ... über ein definiertes Interface.
Ich will dir da jetzt nicht alles erzählen ... wäre viel zu lang!
Im Grunde kannst du dir vorstellen:
Ein Modul, die in eine Blackbox ein Objekt vom Typ Command schickt. Die Blackbox leitet das Command dann an andere Module weiter, die auch mit der Box verbunden sind.
Um ein Command in das System zu senden, muss klarerweiße eine Funktion aufgerufen werden, die so lange blockiert, bis das Command an alle anderen Module verteilt wurde.
Aber nicht so lange bis Alle das Command verabeitet haben! Einfach aus dem Grund weil die Verarbeitung länger dauern kann und das dann den Sender blockieren würde.
Deshalb werden die Commands im System gebuffert und die Module können sich die Commands abholen.

Jetzt will ich eine Möglichkeit haben, dass der Sender weiß, wann alle Module mit der Verarbeitung eines Commands fertig sind.

Zu sagen ist noch, dass ich das in C++/WinAPI entwickelt hab und eigentlich schon fertig bin ... will das jetzt aber auf .NET portieren. Ganze einfach weil .NET GEIL ist
Z.b war es bis jetzt schwierig die Blackbox PC-übergreifend zu gestalten, weil ich das Command nur über umwege seriell (über Sockets) verschicken konnte ... jetzt einfach serialisieren und fertig ^^

So siehts jetzt aus:

class IUnknown
{
    //Inkrementiert den RefCounter
    DWORD AddRef ();
    //Dekrementiert den RefCounter .. wenn er 0 wird, wird das Objekt zerstört
    //Wenn bWait=TRUE ist, dann wartet die Funktion bis das Objekt wirklich
    //zerstört wurde und dekrementet nicht nur
    DWORD Release (BOOL bWait = FALSE);
}

class ICommand : public IUnknown
{
   ...
}

//Senden

//Command erzeugen
   ICommand* pCommand = m_pInteract->CreateCommand ("DATA");
   //Senden
   m_pInteract->CreateCmdSend ()->SendCommand (pCommand);
   //Warten bis Command von allen Empfängern verarbeitet wurde
   pCommand->Release (TRUE);

//Empfangen

//Bevor das Command jetzt an diese Funktion (des anderen Moduls) weitergeleitet wird, wurde pCommand->AddRef () aufgerufen.
//Diese Funktion wird nicht mit der CPU Zeit des Senders aufgerufen ... ein anderen Thread ruft sie auf.
void ReceiveFunction (ICommand* pCommand)
{
    //Verarbeitung
    ....

    pCommand->Release ();
}

Daher mit dem umstieg auf .NET sehr vieles an Code weggefallen ist, dachte ich, ich bring vielleicht das IUnknown auch weg und kann auch direkt herausfinden, wann das Objekt keiner mehr braucht.
Natürlich könnte ich den Rufzeichen-Destruktor :p überladen, aber dann wird der Sender immer blockiert bis sich die GC entschließt aufzuräumen.

Hoffe das war kurz und verständlich

Jochen Kalmbach

Due rufst doch die Komponenten selber auf... warum zählst Du nicht einfach mit bis alle Aufrufe beendet wurden???

Xatian

Ja das mach ich ja jetzt eh so ^^
Mit dem IUnknown ....

Nur wenn ich direkt Handels zählen könnte, die ein Objekt referenzieren (weil das z.b. in den Metadaten des Objektes steht), warum soll ich dann im Objekt einen Zähler mitlaufen lassen??

Die Frage ist, obs das so ist wenn ja wie ich an die Info komm?!

Ich denke schon das es möglich ist, weil ja die GarbageCollection erst ein Objekt löscht, wenn es kein Handle mehr drauf gibt ... also muss die GC ja wissen wie viele Handles noch im Umlauf sind.
Frage ist ob einen Applikation auf diese Info zugriff hat?

MfG

Jochen Kalmbach

Xatian schrieb:

Ich denke schon das es möglich ist, weil ja die GarbageCollection erst ein Objekt löscht, wenn es kein Handle mehr drauf gibt...

Nee.. so ist das nicht... der GC löscht das Objekt erst wenn keine Referenzen mehr darauf bestehen und er Lust dazu hat!

Xatian schrieb:

also muss die GC ja wissen wie viele Handles noch im Umlauf sind.

Das weiss er aber erst, wenn der GC drankommt!!! Und wenn nicht nötig, wird er nicht laufen. Dazu muss er nämlich (per default) *alle* Deine Threads anhalten und nachzählen!

Xatian schrieb:

Frage ist ob einen Applikation auf diese Info zugriff hat?

Nein, normalerweise nicht. Ein Debugger kann es hingegen...