Array of TStringList erzeugen

[Kedariodakon]

Zitat:

Zitat von maximov

@Kedariodakon: Dafür kann man lieber eins von diesen tollen delphi-pseudo-templates machen, dann hat man mit vier zeilen code eine solche klasse generisch erzeugt und kann sich den wirklich wichtigen sachen widmen. -> siehe dpCollection template!

Ok die schau ich mir mal an ^^

[malo]

Zitat:

Zitat von maximov

Zitat:

Zitat von malo

Irgendwie kapiere ich jetzt immer noch nichts... mit arrays geht das so:

Delphi-Quellcode:

type
  TMyType = string;

var: MeinArray: array of TMyType;
begin
  TMyType[0] := 'Hallo Welt';
end;

Und mit Klassen muss ich irgendwelche Umwege über irgendwelche Klassen gehen? Wo ist da der Vorteil? Ich sehe da nur unnötige Arbeit drin.

mal ehrlich! Schon das beispiel ist grob falsch, denn du hast vergessen das array zu vergrössern. Das zeigt auch schon warum eine klasse nicht so falsch wäre: Sie nimmt uns extrem viel arbeit ab, da sie sich selbst um solche sache kümmert und uns damit nicht belästigt. Was ist denn so schlimm an einer klasse?

Eine Klasse erhöht extrem die Tipparbeit, finde ich. "Einfach mal so" eine Klasse für etwas zu schreiben finde ich einfach nur nervig. In diesem Beispiel würde ich es jedoch evtl. sogar machen, das Problem liegt aber darin, dass ich einfach nicht verstehe, wie man obiges Beispiel von mir (evtl. dann mit SetLength) mit TList oder TObjectList lösen könnte. Die Klasse zu erzeugen ist nicht das Problem. Aber wie lege ich einen Typ darin fest? Ich hab zwar auch schon ein paar Codeschnipsel bekommen, für die ich auch sehr dankbar bin, aber ich habe immer noch nichts verstanden :roll:

[Kroko1999]

Delphi-Quellcode:

type
  TMyClass = class(TObjectList)
    private
    function GetItem(AIndex: Integer): TStringList;

    protected

    public
      procedure NewClass;
      property Items[AIndex: Integer]: TStringList read GetItem;
  end;

function TMyClass.GetItem(AIndex: Integer): TStringList;
begin
  if AIndex<Count then Result := TStringlist(inherited Items[AIndex])
                  else Result := nil;
end;

procedure TMyClass.NewClass;
begin
  Add (TStringList.Create);
end;

procedure Test; // Vor.: MyClass ist created
begin
  myClass.NewClass;
  MyClass.Items[0].Add ('Hallo');
end;

[Kedariodakon]

Öhm???
Also von vorn:
Eine TObjectList ist eine Liste!
Dieser Liste können Objecte vom Typ TObject hinzugefügt werden.
Da alle Klassen von TObject Abgeleitet sind, kannst du jede Klasse da einfach reintun, egal ob das eine TStrings, eine TStringlist oder ein TButton oder Ein TLabel oder oder oder... ist, dies alles past in eine einzige Inztanz...

Hinzugefügt werden sie einfach mit Add...

So das raushollen ist ein wenig schwieriger, gerade dann, wenn man TLabels, TButtons, TForms und Co darin hat, aber dafür gibts ja abfragen ala

Delphi-Quellcode:

 If ... Is TButton Then ... := As TButton;

Eigendlich ist das einfachste OOP ...

Schau doch einfach nochmal eine Seite zurück auf mein Beispiel, mit dem TMaloObj und der TMaloObjList, da ist TMaloObj ein Object (irgendeins) und TMaloObjList ist die Liste zu diesem Object...

Wenn du die paar ZEilen dort vom Beispiel verstanden hast, kannst du dir ja mal die dpCollection anschauen, denn es bringt nach meiner Meinung nix, was zu benutzen, was man nicht versteht...

Bye

[maximov]

Zitat:

Zitat von malo

...
Eine Klasse erhöht extrem die Tipparbeit, finde ich. "Einfach mal so" eine Klasse für etwas zu schreiben finde ich einfach nur nervig. In diesem Beispiel würde ich es jedoch evtl. sogar machen, das Problem liegt aber darin, dass ich einfach nicht verstehe, wie man obiges Beispiel von mir (evtl. dann mit SetLength) mit TList oder TObjectList lösen könnte. Die Klasse zu erzeugen ist nicht das Problem. Aber wie lege ich einen Typ darin fest? Ich hab zwar auch schon ein paar Codeschnipsel bekommen, für die ich auch sehr dankbar bin, aber ich habe immer noch nichts verstanden :roll:

Die tipparbeit ist nicht der kritische faktor! Du kannst 100 stunden tipparbeit einsparen, wenn du dir eine stunde mal gedanken machen würdest. Alles was du brauchst ist das, was hier im thread gesagt wurde und die bereitschaft es verstehen zu wollen.


@Kedariodakon: Es geht nicht um die dpCollection, sondern eher um die technik des templates. Damit kann man nämlich mit 4 zeilen code eine komplette typisierte objektliste erzeugen.

[Kedariodakon]

Zitat:

Zitat von maximov

@Kedariodakon: Es geht nicht um die dpCollection, sondern eher um die technik des templates. Damit kann man nämlich mit 4 zeilen code eine komplette typisierte objektliste erzeugen.

das ist schon klar, nur kann er nicht mal selber eine machen, wie soll das den dann mit der handhabung der dpCollection aussehen? :gruebel:


Bye

[Robert_G]

Zitat:

Zitat von Kedariodakon

Zitat:

Zitat von maximov

@Kedariodakon: Es geht nicht um die dpCollection, sondern eher um die technik des templates. Damit kann man nämlich mit 4 zeilen code eine komplette typisierte objektliste erzeugen.

das ist schon klar, nur kann er nicht mal selber eine machen, wie soll das den dann mit der handhabung der dpCollection aussehen? :gruebel:

Ein Collection Descendant wäre hier doch total ungeeignet.
TCollection schluckt nur TCollectionItem-Nachfahren!
Will man Objekte verwalten wäre eine TObjectList ein passabler Anfang. ;)

Und wen so ein Template interessiert...
Nix einfacher als das. ;)

• Du nimmst wie ich eine bestehende, eingestaubte Objectlist Ableitung
• Eine Runde Search'nReplace um die Bezeichner so scheußlich wie möglich zu kriegen. (Sie sollten ja keineswegs mit "Real Life" Bezeichnern kollidieren. ;)
• ein bisschen bedingte Kompilierung (Die Einfachheit des Delphis Compilers ist hier mal ein Vorteil :zwinker: )
• ->voilá

Nix weltbewegendes, auf kein Fall etwas schönes.... aber tierisch praktisch :mrgreen:

Delphi-Quellcode:

{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE}
unit TypedObjectList_template;

interface
uses
   Contnrs;

type _OBJECT_LIST_ITEM_ = TObject;

{$ENDIF TYPED_OBJECT_LIST_TEMPLATE}

{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

// Jedi's include to evaluate compiler version...
{$INCLUDE Jedi.inc}


type
   _OBJECT_LIST_IENUM_ = interface;
   _OBJECT_LIST_ENUM_ = class;
   _OBJECT_LIST_ = class(TObjectList)
   protected
      function  GetItem(Index: Integer): _OBJECT_LIST_ITEM_; virtual;
      procedure SetItem(Index: Integer; const Value: _OBJECT_LIST_ITEM_); virtual;
   public
      function Add(aObject: _OBJECT_LIST_ITEM_): Integer; reintroduce; virtual;
      function Extract(Item: _OBJECT_LIST_ITEM_): _OBJECT_LIST_ITEM_; reintroduce; virtual;
      function Remove(aObject: _OBJECT_LIST_ITEM_): Integer; reintroduce; virtual;
      function IndexOf(aObject: _OBJECT_LIST_ITEM_): Integer; reintroduce; virtual;
      procedure Insert(Index: Integer; aObject: _OBJECT_LIST_ITEM_); reintroduce; virtual;
      function First: _OBJECT_LIST_ITEM_; reintroduce;
      function Last: _OBJECT_LIST_ITEM_; reintroduce;
      property Items[Index: Integer]: _OBJECT_LIST_ITEM_
         read  GetItem
         write SetItem; default;

      function GetIEnumerator(): _OBJECT_LIST_IENUM_;
{$IFDEF COMPILER9_UP}
      function GetEnumerator(): _OBJECT_LIST_ENUM_;
{$ENDIF COMPILER9_UP}
   end;

   _OBJECT_LIST_IENUM_ = interface
      function MoveNext: Boolean;
      function GetCurrent: _OBJECT_LIST_ITEM_;
      property Current: _OBJECT_LIST_ITEM_ read GetCurrent;
   end;

   _OBJECT_LIST_ENUM_ = class(TInterfacedObject, _OBJECT_LIST_IENUM_)
   private
      fCollection: _OBJECT_LIST_;
      fIndex: Integer;
      constructor Create(List: _OBJECT_LIST_);
   public
      function MoveNext: Boolean;
      function GetCurrent: _OBJECT_LIST_ITEM_;
      property Current: _OBJECT_LIST_ITEM_ read GetCurrent;
   end;


{$ENDIF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE}
implementation

{$DEFINE TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}
{$ENDIF TYPED_OBJECT_LIST_TEMPLATE}

{$IFDEF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

{ _OBJECT_LIST_ITEM_ }

function _OBJECT_LIST_.Add(aObject: _OBJECT_LIST_ITEM_): Integer;
begin
   RESULT := inherited Add(aObject);
end;

function _OBJECT_LIST_.Extract(Item: _OBJECT_LIST_ITEM_): _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited Extract(Item));
end;

function _OBJECT_LIST_.First: _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited First());
end;

function _OBJECT_LIST_.GetItem(Index: Integer): _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited Items[Index]);
end;

function _OBJECT_LIST_.IndexOf(aObject: _OBJECT_LIST_ITEM_): Integer;
begin
   RESULT := inherited IndexOf(aObject);
end;

procedure _OBJECT_LIST_.Insert(Index: Integer; aObject: _OBJECT_LIST_ITEM_);
begin
   inherited Insert(Index, aObject);
end;

function _OBJECT_LIST_.Last: _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited Last());
end;

function _OBJECT_LIST_.Remove(aObject: _OBJECT_LIST_ITEM_): Integer;
begin
   RESULT := inherited Remove(aObject);
end;

procedure _OBJECT_LIST_.SetItem(Index: Integer;   const Value: _OBJECT_LIST_ITEM_);
begin
   inherited Items[Index] := Value;
end;

{$IFDEF COMPILER9_UP}

function _OBJECT_LIST_.GetEnumerator: _OBJECT_LIST_ENUM_;
begin
  RESULT := _OBJECT_LIST_ENUM_.Create(self);
end;

function _OBJECT_LIST_.GetIEnumerator: _OBJECT_LIST_IENUM_;
begin
   RESULT := GetEnumerator();
end;

{$ELSE}

function _OBJECT_LIST_.GetIEnumerator: _OBJECT_LIST_IENUM_;
begin
   RESULT := _OBJECT_LIST_ENUM_.Create(self);
end;

{$ENDIF COMPILER9_UP}

constructor _OBJECT_LIST_ENUM_.Create(List: _OBJECT_LIST_);
begin
  fIndex := -1;
  fCollection := List;
end;

function _OBJECT_LIST_ENUM_.GetCurrent: _OBJECT_LIST_ITEM_;
begin
  RESULT := fCollection.GetItem(fIndex);
end;

function _OBJECT_LIST_ENUM_.MoveNext: Boolean;
begin
  inc(fIndex);
   RESULT := (fIndex > -1) and (fIndex < fCollection.Count);
end;


{$WARNINGS off}
{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE}
end.
{$ENDIF TYPED_OBJECT_LIST_TEMPLATE}
{$ENDIF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}
{$DEFINE TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

Die Verwendung ist denkbar einfach (die 4 Zeilen, von denen maximov sprach ;) )

Delphi-Quellcode:

interface
uses Contnrs; /// <- wichtig!

type
   TSomeClass = class
   private
      fSomeProperty: Integer;
   public
      property SomeProperty: Integer
         read fSomeProperty
         write fSomeProperty;
   end;


{$DEFINE TYPED_OBJECT_LIST_TEMPLATE}
type _OBJECT_LIST_ITEM_ = TSomeClass;
{$INCLUDE TypedObjectList_template.pas}
   TSomeClassList = _OBJECT_LIST_;
implementation
{$INCLUDE TypedObjectList_template.pas}
end.

direkt angewand könnte man vor D2005 so durch sie laufen:

Delphi-Quellcode:

   with SomeClassList.GetIEnumerator() do
      while MoveNext() do
         WriteLn(Current.SomeProperty);

In D2005 geht nun auch gleich das hier:

Delphi-Quellcode:

var
   SomeInstance :TSomeClass;
begin
   for SomeInstance in SomeClassList do
      WriteLn(SomeInstance.SomeProperty);

[maximov]

Wenn das nicht einfach ist - abgesehen davon, dass es hässlich aussieht - dann weiss ich auch nicht!

[Robert_G]

Zitat:

Zitat von maximov

Wenn das nicht einfach ist - abgesehen davon, dass es hässlich aussieht - dann weiss ich auch nicht!

Aber das "hässlich" ist kein wirkliches Problem... Schließlich muss man sich den Apettiszügler so schnell nicht mehr ankieken. :mrgreen:
Nur noch benutzen! :)