TCollection & TCollectionitem Tutorial

[MrBrown90]

Natürlich weiß ich wie Schleifen, Arrays usw funktionieren ...ich hab nur mein Augenmerk auf Threads gelegt, weil ich da absolut keine Ahnung davon hatte.

Und nein, ich bin mir nicht sicher ob es der richtige Weg ist. Aber was spielt das hier für eine Rolle? Fertig machen werde 8ch das Studium

[4dk2]

Zitat:

Zitat von MrBrown90 (Beitrag 1386327)

Natürlich weiß ich wie Schleifen, Arrays usw funktionieren ...ich hab nur mein Augenmerk auf Threads gelegt, weil ich da absolut keine Ahnung davon hatte.

Und nein, ich bin mir nicht sicher ob es der richtige Weg ist. Aber was spielt das hier für eine Rolle? Fertig machen werde 8ch das Studium

DAS GANZE GEHÖRT hier aber nicht hin.
Mach bitte einen eigenen Thread dazu auf.

[MrBrown90]

Okay, Sorry ist wohl etwas vom ursprünglichen Thema abgewichen, dann wieder zurück zu TCollection.

Ich habe jetzt versucht, dass beim Programmstart 6 Threads erstellt werden und in einer TCollection gespeichert werden. Hier mal der Code dazu

Delphi-Quellcode:

TMyThread = class(TThread)
  protected
    counter: integer;
    procedure Execute; override;
    procedure prog;
  public
    constructor Create;
  end;



TThreadItem = class(TCollectionItem)
  private
    FLength: integer;
  public
    constructor Create(ACollection: TCollection); override;
  published
    property Length: integer read FLength write FLength;
  end;
 
  TThreadlist = class(TCollection)
  private
 
    procedure SetItems(Index: integer; AValue: TThreadItem);
  public
    constructor Create;
    function GetItems(Index: integer): TThreadItem;
    function AddEx(ite: TMyThread): TThreadItem;
    property Items[Index: integer]: TThreadItem read GetItems
      write SetItems; default;
  end;

implementation




constructor TThreadItem.Create(ACollection: TCollection);
begin
  if Assigned(ACollection) then
    inherited Create(ACollection);
end;
 


constructor TThreadlist.Create;
begin
  inherited Create(TThreadItem);
end;


constructor TMyThread.Create;
begin
  inherited Create(True);
end;


function TThreadlist.GetItems(Index: integer): TThreadItem;
begin
  result := TThreadItem(inherited Items[index]);
end;

function TThreadlist.AddEx(ite: TMyThread): TThreadItem;
begin
  result := inherited Add as TThreadItem;
end;


function TThreadlist.AddEx(ite: TMyThread): TThreadItem;
begin
  result := inherited Add as TThreadItem;
end;

procedure TForm7.FormCreate(Sender: TObject);
var
  i: integer;
  Thread:array [0..5] of  TMyThread;
  p: TThreadItem;
begin
  ThreadL := TThreadlist.Create;
  for i := 0 to 5 do
  begin
    ListBox1.Items.AddObject('Thread Nr. ' + IntToStr(i), TObject(i));
  end;
  for i := 0 to 5 do
  begin
    Thread[i]:=TMyThread.Create;
    ThreadL.AddEx(Thread[i]);
  end;
ShowMessage(IntToStr(ThreadL.Count));
end;

Ist das soweit richtig?

[TiGü]

Ich bin kurz davor, einfach den Quelltext in gut und fertig zu posten, aber ich habe die Hoffnung noch nicht aufgeben.

Bitte folgende Fragen beantworten:
Wo genau findet bei dir die Zuordnung TThreadItem zu TMyThread statt?
oder
Woher weiß das TThreadItem, dass ihm ein TMyThread zugeordnet ist?

Was macht FLength in TThreadItem, wozu dient es?
Wozu dient das Array

Delphi-Quellcode:

Thread:array [0..5] of TMyThread;

?

Was soll am Ende mit deiner Collection geschehen? Was ist das Ziel?


PS: TThreadlist.AddEx ist zweimal reinkopiert und TThreadlist.SetItems fehlt.

[MrBrown90]

Danke für die Geduld.

Ja, es findet wohl gar keine Zuordnung statt. Die sollte dann wahrscheinlich im Instructor von TThreaditem stattfinden oder.

Flength hab ich entfernt, war Quatsch.

Und das Array ergibt eigentlich aauch kein Sinn.

Ich möchte das beim Programmstart 6 Instanzen von TMyThread erstellt werden und in meiner TCollection eingefügt werden

Wahrscheinlich so der richtige Ansatz ?

Delphi-Quellcode:

for i := 0 to 5 do

  begin

    ThreadL.AddEx(Thread.Create);

  end;

Dann soll es so funktionieren
Start-Button drücken
THREAD mit bestimmter ID startet sie
Und dieses Threads will ich mir aus meiner TCollection holen

[TiGü]

Zitat:

Zitat von MrBrown90 (Beitrag 1386389)

Ja, es findet wohl gar keine Zuordnung statt. Die sollte dann wahrscheinlich im Instructor von TThreaditem stattfinden oder.

Constructor, das Wort heißt Constructor.
Aber wahrscheinlich schreibst du immer noch am Handy und das war die Autokorrektur.

Wenn es sich richtig anfühlt, dann wird es richtig sein! Mach es so!

Jetzt musst du noch einen erweiterten TMyThread-Constructor bauen, mit dessen Hilfe du die ID (0 bis 5) übergibst und diese ID innerhalb der TMyThread-Instanz speicherst.

[MrBrown90]

Ja ich meinte Constructor. Aber ich verstehe leider überhaubt nicht, wie ich das umsetzten soll.

So ist Quatsch oder ?

Delphi-Quellcode:

TThreadItem = class(TCollectionItem)

  private

  public

    FThreadItem:TMyThread;

    constructor Create(ACollection: TCollection); override;

  published

  end;

 

constructor TThreadItem.Create(ACollection: TCollection);

begin

    inherited Create(ACollection);

    FThreadItem:=TMyThread.Create;

 

end;

[TiGü]

Wäre eine Möglichkeit.
Ich würde prinzipiell die Instanz von TMyThread von außen erzeugen und über eine Property eingeben, aber das ist jetzt Geschmackssache und erstmal irrelevant.
Das TThreadItem ist dann in deiner Lösung verantwortlich für die Erzeugung der TMyThread-Instanzen und auch für deren Anhalten/Freigabe/Zerstörung.

Mache dir nun Gedanken, wie die jeweilige TMyThread-Instanz ihre ID erhält.
Vergleiche meinen Vorschlag mit dem erweiterten Constructor.

[MrBrown90]

Okay, also wenn ich das richtig verstehe, muss ich dann auch im deconstructor meine Threads terminieren und freigeben?


Mit den Ids hätte ich jetzt über die Listbox gelöst...oder ist das wieder schlecht, weil ich wieder direkt auf die GUI zugreife?

Delphi-Quellcode:

for i := 0 to 5 do

  begin

   ListBox1.Items.AddObject('Thread Nr. ' + IntToStr(i), TObject(ThreadL.AddEx));

  end;

[DeddyH]

Wenn der Hauptthread auf die GUI zugreift, ist das unproblematisch. Nur wenn Deine TThread-Instanzen das tun sollen, muss das (wie auch immer) synchronisiert geschehen, sei es per Messages, TThread.Synchronize oder TThread.Queue.