Tut mir leid für den Betreff aber mir fällt nichts ein zu meinem Problem!

Ich habe eine Klasse TThreads type TThreads = class In der public-Ebene habe ich eine Hand voll Variablen.
Eine davon zielt auf eine Thread-Unit (also den Thread selber). Die andere auf eine normale Klasse, kein Thread.

In etwa

markieren

Delphi-Quellcode:

type
 TThreads = class
 private
  //
 public
  itemX: TMeinThread;
  itemY: TIrgendeineWeitereKlasse;
  // ein paar wenige weitere Variablen
 end;

Im Thread TMeinThread gibt es eine Variable bThreadSleeping welche ich so ansprechen kann:
aThreadInfo.ThreadList.Items[i].itemX.bThreadSleeping aThreadInfo ist folgendermaßen deklariert

markieren

Delphi-Quellcode:

type
 TThreadInfo = packed record
  ThreadList: TObjectList<TThreads>;
  iThreadID: Cardinal;
  ThreadHandle: THandle;
 end;

aThreadInfo: TThreadInfo;

Threads füge ich so hinzu
aThreadInfo.ThreadList.Add(TThreads.Create(....)); Funktioniert seit vielen Jahren einwandfrei!
Nun brauche ich bThreadSleeping aber im Thread selber und auch in itemY, also TIrgendeineWeitereKlasse.

Wie komme auch aus TMeinThread und TIrgendeineWeitereKlasse an eine Variable dran, die im übergeordneten Element liegt? Also einem TThreads-Element?

Wie wäre es die Variable in ein Interface auszulagern? Das kann dann der Thread genauso kennen wie die andere Klasse.

Ist das ein eigener Threadpool? Da gibt es schon so viele fertige Implementierungen, dass ich schon lange keine eigene Implementierung mehr nutze. Alleine schon was in der OmniThreadLibrary oder der mit Delphi mitgelieferten Parallel Programming Library möglich ist...

Was passiert denn genau außenrum?

Du suchst jetzt aber nicht thread-local Variablen?
(Wenn ja: Titeländerung zu "Threadlokaler Zugriff auf Variablen"?)

Vielleicht lässt sich dein Problem aber auch auf makroskopischerer Ebene umgehen? Was möchtest du denn genau tun? Bzw was ist das Ziel?

Brighty

Interfaces, nein danke

Doch das ist mein eigener ThreadPool. Eine ObjectList mit Threads drin und jeder Thread hat noch 2 Unterklassen.

Ich weiß ja eben nicht wie das heißt was ich suche. Aber die 2 Unterklassen sollten irgendwie an eine Variable im ThreadList.Items[i] selbst drankommen können.

Wie soll das denn mit der Threading-Library funktionieren?

Also wenn das eine 1:1 Zuordnung ist, dann kannst du vielleicht dort, wo du Zugriff auf die Klasse brauchst eine Referenz dorthin vergeben (also in dem Fall die TThreads Referenz).
Im Allgemeinen bin ich aber gegen zirkuläre Referenzen (z.B. Klasse A kennt Klasse B und Klasse B kennt Klasse A,...), weil das oft auf ein generelleres Problem im Entwurf zeigt, das man eventuell refactoren kann (oft sind die 1:1 Objekte dann semantisch sehr ähnlich und durch die zirkuläre Referenzen stark miteinander verbunden...). Daher meine Frage nach dem Entwurf

Ich mache das Ganze sehr gerne besser. Aber ohne Interfaces denn die A) verstehe ich nicht und B) habe ich keine Lust sie jetzt schnell zu erlernen.

Also... gerne mache ich das alles komplett anders.

Was möchtest du denn tun? Bzw was ist dein Ziel?

Ich versuche noch immer zu verstehen, was genau dein Problem ist.

(totally unrelated zu Interfaces: Ich glaube, dass du grundsätzlich das Prinzip von Interfaces schon verstanden hast, wenn du ein bisschen Objektorientierung verwendet hast; Interfaces sind nichts anderes als Klassen ohne Implementierung. Habe keine Angst davor! Der Vorteil ist nur, dass du manchmal flexibler bist; Die effektive Verwendung von Interfaces führt oft einfach dazu, dass dein Modell weniger stark zusammenhängt. Ich glaube aber dein Problem sitzt in dem Fall aber wo anders...)

Zitat:

Aber ohne Interfaces

Er will es nicht und hat es auch schon in anderen Threads gesagt.
Lasst ihm seinen Willen

Ist ja auch nicht weiter tragisch.

gruss

Mein Ziel grob erklärt:

mein hat eine ListView und jede ListView ist ein Datensatz. Jeder, ich nenne es mal "Eintrag", kann einen Thread im Hintergrund laufen haben, muss aber nicht.

Wenn aber ein Thread im Hintergrund für einen Eintrag laufen soll, dann wird meiner ObjectList über Add eine Instanz von TThreads übergeben.
Im Create von TThreads wird der eigentliche benötigte Thread erzeugt.

Über aThreadInfo.ThreadList.Items[i].itemX kann ich nun auf meinen Thread zugreifen. Über aThreadInfo.ThreadList.Items[i].VARIABLEXYZ auch auf Variablen der Klasseninstanz selber (nicht des Threads, der Thread ist itemX).

Ich möchte nun, dass mein Thread itemX auf Variablen der Klasseninstanz zugreifen kann, dem er (der Thread) angehört.

Aktuell haben bei mit itemX und itemY jeweils eine Variable, die den gleichen Zweck erfüllen. Deswegen dachte ich packe ich die in die Klasseninstanz dann habe ich nur noch eine.

Beispiel: aThreadInfo.ThreadList.Items[i].itemX.bPause würde den Thread (itemX) dann pausieren (setter). Hier wäre es aber besser eine einzige Variable zu haben, die ich aus beiden Teilen, itemX und itemY, abrufen kann.

Zitat:

Er will es nicht und hat es auch schon in anderen Threads gesagt.

Grund ist ganz einfach, dass ich Interfaces nicht verstehe und Code den ich nicht verstehe möchte ich nicht einbauen

Wenn ich dich richtig verstanden habe, möchtest du innerhalb eines Threads auf ein Set von Variablen zugreifen, die für diesen Thread zur Abarbeitung seiner eigenen Tätigkeit wichtig sind. Was hindert dich daran, bei der Initialisierung des Threads diesen "Kontext", also eine Referenz auf dein übergeordnetes Objekt diesem zu übergeben? (also eine Referenz auf dein jeweiliges TThreads)