TObjectList als Result

[Sir Rufo]

Zitat von TiGü:

Zitat von Sir Rufo:

Ähm, ja, so ist doch die Frage, darum geht es doch dem TE (der übrigens auch nur Delphi 7 hat, was soll der da mit Generics?)

Eben!
Mir ist schleierhaft, was der TE mit der von Stevie vorgeschlagenen, selbst gebastelten "TInterfacedObjectList" anfangen soll?!

Delphi-Quellcode:

unit Unit1;

interface

uses
  Contnrs,
  Classes;

type
  IObjectList = interface
    ['{056BC23C-2F12-40DF-A0F7-2A9AE55ADADB}']
    function Add( AObject: TObject ): Integer;
    function Extract( Item: TObject ): TObject;
    function ExtractItem( Item: TObject; Direction: TList.TDirection ): TObject;
    function Remove( AObject: TObject ): Integer; overload;
    function RemoveItem( AObject: TObject; ADirection: TList.TDirection ): Integer;
    function IndexOf( AObject: TObject ): Integer;
    function IndexOfItem( AObject: TObject; ADirection: TList.TDirection ): Integer;
    function FindInstanceOf( AClass: TClass; AExact: Boolean = True; AStartAt: Integer = 0 ): Integer;
    procedure Insert( Index: Integer; AObject: TObject );
    function First: TObject;
    function Last: TObject;
    function GetOwnsObjects: Boolean;
    procedure SetOwnsObjects( const Value: Boolean );
    property OwnsObjects: Boolean read GetOwnsObjects write SetOwnsObjects;
    function GetItem( Index: Integer ): TObject;
    procedure SetItem( Index: Integer; AObject: TObject );
    property Items[Index: Integer]: TObject read GetItem write SetItem; default;
  end;

  TInterfacedObjectList = class( TObjectList, IInterface, IObjectList )
  private // IInterface
    FRefCount: Integer;
    function QueryInterface( const IID: TGUID; out Obj ): HRESULT; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  private // IObjectList
    function GetOwnsObjects: Boolean;
    procedure SetOwnsObjects( const Value: Boolean );
  end;

implementation

{ TInterfacedObjectList }

function TInterfacedObjectList.GetOwnsObjects: Boolean;
begin
  Result := OwnsObjects;
end;

function TInterfacedObjectList.QueryInterface( const IID: TGUID; out Obj ): HRESULT;
begin
  if GetInterface( IID, Obj )
  then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

procedure TInterfacedObjectList.SetOwnsObjects( const Value: Boolean );
begin
  OwnsObjects := Value;
end;

function TInterfacedObjectList._AddRef: Integer;
begin
  Result := AtomicIncrement( FRefCount );
end;

function TInterfacedObjectList._Release: Integer;
begin
  Result := AtomicDecrement( FRefCount );
  if Result = 0
  then
    Destroy;
end;

end.

Und dann im seinem Quelltext

Delphi-Quellcode:

function TForm1.imageloader: IObjectList;
begin
    Result := TInterfacedObjectList.Create( False );
    Result.Add(Image1);
    Result.Add(Image2);
    Result.Add(Image3);
    Result.Add(Image4);
    Result.Add(Image5);
    Result.Add(Image6);
    Result.Add(Image7);
end;

procedure TForm1.Button1Click(Sender: TObject);

var
    MyList: IObjectlist;
    counter : integer;
begin

    Mylist := ImageLoader; // Jetzt Interface, jetzt keine Speicherlecks mehr
    Allrounder := TImage(Imageloader.Items[5]); // <- da wird schon wieder eine erzeugt!!!, aber ist ja JETZT kein Problem mehr
    Allrounder.Picture.LoadFromFile('Unbenannt.jpg');

end;

[TiGü]

Zitat von Sir Rufo:

Siehe mein kurz zuvor getätigtes Edit!

[DeddyH]

Wären dann aber nicht auch anschließend die TImages weg? Ich tendiere in diesem Fall eher zu himitsus Vorschlag mit dem dynamischen Array, das erfordert weniger Aufwand und sollte vollkommen ausreichend sein.

[Sir Rufo]

Zitat von DeddyH:

Wären dann aber nicht auch anschließend die TImages weg? Ich tendiere in diesem Fall eher zu himitsus Vorschlag mit dem dynamischen Array, das erfordert weniger Aufwand und sollte vollkommen ausreichend sein.

Oh ja, da muss ich nochmal einen Manntag Arbeit reinstecken, damit das nicht passiert

Delphi-Quellcode:

Result := TInterfacedObjectList.Create( 
  {OwnsObjects} False );

Das mit den Arrays kommt auf den Einsatzzweck an (hier bestimmt völlig ausreichend). Es macht aber nichts, so eine Interface-ObjectList in der Hinterhand zu haben, vor allem, wenn man die LifeTime der Elemente damit verwalten will. Keiner mehr Interesse an der Liste, dann alles ab in die Tonne

[bernau]

Schon lustig, dieser Thread

Der TE stellt eine Frage. Was er mit diesem Code will, ist garnicht wirklich klar. Er hat auch keine Antwort geschrieben.

Es wird hier aber trotzdem weiter philosophiert Wie Ihr auf den ganzen Interface-Kram kommt, kann ich nicht wirklich nachvollziehen. Ist zwar interessant, hat aber mit dem Problem des TE nichts zu tun. Oder?

Edit: Bis Beitrag #7 war es noch themenbezogen.

[mkinzler]

Der Beste Code ist nicht immer der passende Code. Wenn man sich die Fragen des TE mal durchliest, wird man Sehen, dass er diese Lösung hier schon im Ansatz nicht verstehen wird, da ihm ja offensichtlich die Grundlagen dafür fehlen.
Den Verweis auf das Schlißen derselbigen wird konsequent ignoriert.

Eigentlich scheinen sich alle Fragen, um das selbe Programm/Problem zu drehen.

[Sir Rufo]

@bernau

Die Lösung kam schon mit der ersten Antwort, und der Rest handelt von den Seiteneffekten (Speicherlecks).

[bernau]

Zitat von Sir Rufo:

@bernau

Die Lösung kam schon mit der ersten Antwort, und der Rest handelt von den Seiteneffekten (Speicherlecks).

Deshalb werden Interfaces vorgeschlagen? Finde ich als Lösung für den TE sehr verwirrend. Ein Hinweis auf Mylist.Free genügt doch, wie er von "Neutral General" vorgeschlagen wurde.

[bernau]

Die Frage für mich ist, warum erzeugt der TE ein Form, zieht dort acht TImages (Image1 bis Image7 und Allrounder) drauf, die beim erzeugen des Formulars alle instanziert sind, und überschreibt kurz gefasst "Allrounder" mit "Image5". Ein Stück Code der für mich keinen Sinn macht.

[Sir Rufo]

Zitat von bernau:

Zitat von Sir Rufo:

@bernau

Die Lösung kam schon mit der ersten Antwort, und der Rest handelt von den Seiteneffekten (Speicherlecks).

Deshalb werden Interfaces vorgeschlagen? Finde ich als Lösung für den TE sehr verwirrend. Ein Hinweis auf Mylist.Free genügt doch, wie er von "Neutral General" vorgeschlagen wurde.

Dafür werden/wurden auch Interfaces vorgeschlagen, ja völlig legitim. Entscheiden soll er selber, was ihm am Besten in den Kram passt.