Wirkliche Unterschiede??

[Delbor]

Hi zusammen

In einem der in Delphi enthaltenen Demos gibt es eine einzige Prozedure, die in einem Case..of-Block zwischen allen unter Delphi möglichen DBs unterscheidet. In den den einzelnen Selektorblöcken befinden sich eine ganze Menge Konstrukte wie das unten nicht auskommentierte.
Die ganzen with..do begin..end-Konsttrukte benötigen insgesamt geschätzt wohl ebensoviel Platz wie die eigentlichen Anweisungen, was die komplette Prozedur sagenhaft aufbläht. Um etwas mehr Übersichtlichkeit zu erreichen, habe ich unter einem der Selektoren diese with-Konstrukte durch solche zu ersetzen, wie sie der ausgeklammerte Block widergibt - und prompt meckerte Delphi wegen unbekanntem Bezeichner PrecMax(zum Bleistift).

Delphi-Quellcode:

      with MapRules.Add do begin
        PrecMax := 19;
        PrecMin := 4;
        SourceDataType := dtFmtBCD;
        TargetDataType := dtCurrency;
      end;

//        MapRules.Add(PrecMax := 2);
//        MapRules.Add(PrecMin := 0);
//        MapRules.Add(SourceDataType := dtFmtBCD);
//        MapRules.Add(TargetDataType := dtBoolean);

An was liegt das? Ich habe zwar eine Vermutung. Aber sowas ist letzten Endes weniger als Halbwissen. Ich selst verwende seit Jahren aus mehreren Gründen keine with do begin - Blöcke mehr.

Gruss
Delbor

[DeddyH]

MapRules.Add wird wohl eine neue Instanz von irgendwas (bin gerade zu faul zum Nachsehen) zurückgeben. Von daher ist Deine Syntax schlicht falsch. Richtig müsste es dann so lauten:

Delphi-Quellcode:

var 
  Dings: TWasAuchImmer;
begin
  Dings := MapRules.Add;
  Dings.PrecMax := 19;
  Dings.PrecMin := 4;
  Dings.SourceDataType := dtFmtBCD;
  Dings.TargetDataType := dtCurrency;

[Bernhard Geyer]

Zitat:

Zitat von DeddyH (Beitrag 1368803)

MapRules.Add wird wohl eine neue Instanz von irgendwas (bin gerade zu faul zum Nachsehen) zurückgeben. Von daher ist Deine Syntax schlicht falsch.

AFAIK funktioniert diese Logik.
Aber wir bauen diese With-Anweisungen überall aus wenn wir in der Unit eh Anpassungen vornehmen.
Diese with-Statements sind immer ein Quell von Überraschungen.

[DeddyH]

Ja, aber darum ging es ja nicht. Ich finde es lobenswert, das with zu eliminieren, wo man darauf trifft, aber man muss es dann auch syntaktisch korrekt machen.

[Hobbycoder]

In dem Code:

Delphi-Quellcode:

MapRules.Add(PrecMax := 2);
MapRules.Add(PrecMin := 0);
MapRules.Add(SourceDataType := dtFmtBCD);
MapRules.Add(TargetDataType := dtBoolean);

Wird 4 mal ein Instanz von Irgenwas erzeugt, und in der Add-Methode jedes mal etwas anderes Übergeben.

Zitat:

Zitat von DeddyH (Beitrag 1368803)

Delphi-Quellcode:

var 
  Dings: TWasAuchImmer;
begin
  Dings := MapRules.Add;
  Dings.PrecMax := 19;
  Dings.PrecMin := 4;
  Dings.SourceDataType := dtFmtBCD;
  Dings.TargetDataType := dtCurrency;

Das hier erzeug aber nur eine Instanz, und das ist dann auch der Unterschied.

[Delbor]

Hi DeddyH
Ehrlich gesagt, war ich auch zu faul, um nachzusehen - ich ging allerdings davon aus, dass mit Add etwas einer Liste oder einer Collection hinzugefügt wird. Also müsste das, was da hinzugefügt wird, unter beiden Schreibweisen schon bekannt sein.

Angenommen, Dings ist ein Object:
Methoden:
-Add;
Propertys:
-Percmax : integer;
-Percmin : integer;
-SourceDataType := TWasAuchImmer;
-TargetDataType := TWasAuchImmer;


Um nun an die Propertys Werte zuzuweisen, brauche ich doch gar keine Methode Add, sondern kann die neuen Werte direkt zuweisen:

Delphi-Quellcode:

Dings.PrecMax := 19;

Delphi-Quellcode:

var
  Dings: TWasAuchImmer;
begin
  Dings := MapRules.Add;
  Dings.PrecMax := 19;
  Dings.PrecMin := 4;
  Dings.SourceDataType := dtFmtBCD;
  Dings.TargetDataType := dtCurrency;

Das hier lese ich so:

Dings ist ein Object der Klasse TWasAuchImmer
Dieser Klasse wird
-eine Unterklasse (Dings.Add)
-ein Property oder
-eine Methode
zugewiesen. Letztere zwei Punkte fallen weg. Somit wäre nur eine Wertzuweisung an die Unterklasse 'Add' der Dings-Klasse möglich. Da 'PrecMax ' in der Unterklasse bekannt ist, gibts auch keinen Fehler.
Aber wer nennt seine Klasse schon 'Add'??

Gruss
Delbor

[DeddyH]

Add ist keine Klasse! Das ist eine Methode (Funktion) der Klasse, von der MapRules ist (TMapRules vermutlich). Diese Funktion gibt Dir eine Instanz zurück, und dieser Instanz weist Du nun die Werte zu.

[bra]

Also so wie ich die gängigen Add-Methoden kenne (bei TListView u.ä.) ist DeddyHs Variante die einzig korrekte Alternative zu dem with...do-Statement.

[Delbor]

Hi HobbyCoder

Zitat:

Das hier erzeug aber nur eine Instanz, und das ist dann auch der Unterschied.

Ich fragte nicht nachdem Unterschied von meinem Codeschnipsel zu demjenigen von DeddyH. Die Frage war nach dem Unterschied der Syntax, wie ich sie in der Demo angetroffen habe und meinem Konstrukt:

Delphi-Quellcode:

      with MapRules.Add do begin
        PrecMax := 19;
        PrecMin := 4;
        SourceDataType := dtFmtBCD;
        TargetDataType := dtCurrency;
      end;

Oben das in der Demo angetroffene Konstrukt, unten das Konstrukt, das ich satt dessen zu verwendsen gedachte und das zu einer AV führte.

Delphi-Quellcode:

//        MapRules.Add(PrecMax := 2);
//        MapRules.Add(PrecMin := 0);
//        MapRules.Add(SourceDataType := dtFmtBCD);
//        MapRules.Add(TargetDataType := dtBoolean);

Gruss
Delbor

[DeddyH]

Hat sich das kompilieren lassen? Damit hätte ich jetzt nicht gerechnet.

[Towmuz]

hier, guckt doch einfach in die Wiki :p

[Hobbycoder]

Zitat:

Zitat von Delbor (Beitrag 1368830)

Hi HobbyCoder

Zitat:

Das hier erzeug aber nur eine Instanz, und das ist dann auch der Unterschied.

Ich fragte nicht nachdem Unterschied von meinem Codeschnipsel zu demjenigen von DeddyH. Die Frage war nach dem Unterschied der Syntax, wie ich sie in der Demo angetroffen habe und meinem Konstrukt:

Delphi-Quellcode:

      with MapRules.Add do begin
        PrecMax := 19;
        PrecMin := 4;
        SourceDataType := dtFmtBCD;
        TargetDataType := dtCurrency;
      end;

Oben das in der Demo angetroffene Konstrukt, unten das Konstrukt, das ich satt dessen zu verwendsen gedachte und das zu einer AV führte.

Delphi-Quellcode:

//        MapRules.Add(PrecMax := 2);
//        MapRules.Add(PrecMin := 0);
//        MapRules.Add(SourceDataType := dtFmtBCD);
//        MapRules.Add(TargetDataType := dtBoolean);

Gruss
Delbor

Zum esten habe ich mich auf den Titel "Wirklich Unterschiede" bezogen.
Zum zweiten, einmal ist es eine Instanz und einmal sind es 4 Instanzen. Ist für mich ein entscheidender unterschied.
Zum dritten, was weiß ich denn, was in der Add-Methode steht, und welche Parameter du da überhaupt übergeben kannst, oder ob es da überladene Methoden gibt. Schau doch mal nach.

Fakt ist jedenfalls, dass With..do alles mit einer Instanz mache und 4 mal x.Add() mit 4.

[Delbor]

HI DeddyH

Zitat:

Add ist keine Klasse! Das ist eine Methode (Funktion) der Klasse, von der MapRules ist (TMapRules vermutlich). Diese Funktion gibt Dir eine Instanz zurück, und dieser Instanz weist Du nun die Werte zu.

Ich ging eigentlich erstmal auch davon aus, dass Add eine Methode von MapRules ist und war deshalb auch erstaunt, dass das Konstrukt

Delphi-Quellcode:

 MapRules.Add(PrecMax := 2);

nicht funktionierte.
Daher auch meine Vermutung, dass Add eine Klasse mit dem Property PrecMax sein müsste. Aber eben: wer nennt seine Klasse schon 'Add'??

@Bernhard Geyer: Die Demo ist das program Indices aus Object Pascal\Database\FireDAC\Samples\Comp Layer\TFDQuery, falls das interessiert.

Gruss
Delbor

[bra]

Jetzt mal blöd gefragt, worum geht es hier eigentlich noch?

Das

Zitat:

Zitat von Delbor (Beitrag 1368801)

Delphi-Quellcode:

      with MapRules.Add do begin
        PrecMax := 19;
        PrecMin := 4;
        SourceDataType := dtFmtBCD;
        TargetDataType := dtCurrency;
      end;

und das

Zitat:

Zitat von Delbor (Beitrag 1368801)

Delphi-Quellcode:

//        MapRules.Add(PrecMax := 2);
//        MapRules.Add(PrecMin := 0);
//        MapRules.Add(SourceDataType := dtFmtBCD);
//        MapRules.Add(TargetDataType := dtBoolean);

ist was vollkommen verschiedenes, sofern sich das zweite überhaupt kompilieren lässt. So das sollte doch inzwischen geklärt sein, oder nicht?

[Delbor]

Hi Hobbycoder

Zitat:

Zum zweiten, einmal ist es eine Instanz und einmal sind es 4 Instanzen. Ist für mich ein entscheidender unterschied.

Hmm....

Delphi-Quellcode:

var Adresslist: TStringlist;

Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Adresslist.Add(xxxx);

Das ist definitiv immer die gleiche Instanz und auch immer die gleiche Add-Methode.
In einem With-Konstrukt würde ich das allerdings so schhreiben:

Delphi-Quellcode:

with Adresslist do begin
Add(xxxx);
Add(xxxx);
Add(xxxx);
Add(xxxx);
end;

Nach dem Angetroffenen Konstrukt ginge dies offenbar aber auch so:

Delphi-Quellcode:

with Adresslist.Add do begin
y:=xxxx;
y:=xxxx;
fy:=xxxx;
dy:=xxxx;
end;

@bra:

Zitat:

ist was vollkommen verschiedenes, sofern sich das zweite überhaupt kompilieren lässt. So das sollte doch inzwischen geklärt sein, oder nicht?

Ich verstehe es jedenfalls noch nicht. Offenbar wird im with-Konstrukt die Methode 'Add' eines Objektes aufgerufen. Oder übersehe ich da einfach, dass in einem "with Object.Add" - Konstrukt der Compiler alles innerhalb als String interpretiert?

Gruss
Delbor

PS: Das hier hab ich allerdings bis jetzt übersehen (Antwort 11 von Towmuz):

Zitat:

hier, guckt doch einfach in die Wiki :p

[DeddyH]

Delphi-Quellcode:

type
  TMyItem = class
    ...
  end;

  TMyItemList = class
    ...
    function Add: TMyItem;
  end;

So oder so ähnlich dürfte die Konstellation aussehen. Der Aufruf von Add führt dazu, dass TMyItemList eine neue Instanz von TMyItem erzeugt, diese in seiner internen Liste ablegt und zurückgibt. Das bedeutet, dass mit jedem Aufruf von Add eine neue Instanz erzeugt und zurückgegeben wird. Jetzt klarer?

[Delbor]

Hi DeddyH

Zitat:

So oder so ähnlich dürfte die Konstellation aussehen. Der Aufruf von Add führt dazu, dass TMyItemList eine neue Instanz von TMyItem erzeugt, diese in seiner internen Liste ablegt und zurückgibt. Das bedeutet, dass mit jedem Aufruf von Add eine neue Instanz erzeugt und zurückgegeben wird. Jetzt klarer?

Ja, vor allem unter Berücksichtigung meines PS im letzten Beitrag! Vielen Dank!

Mein Fehler war offensichtlich, dass ich die Unterschiede von Collections und Listen bisher nicht kannte. Mit ersteren hab ich noch nicht wirklich aktiv gearbeitet.

Gruss
Delbor

[Hobbycoder]

Zitat:

Zitat von Delbor (Beitrag 1368854)

Delphi-Quellcode:

var Adresslist: TStringlist;

Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Adresslist.Add(xxxx);

Ist klar, es werden 4 Instanzen von irgendwas unter AddressList

Zitat:

Zitat von Delbor (Beitrag 1368854)

Das ist definitiv immer die gleiche Instanz und auch immer die gleiche Add-Methode.
In einem With-Konstrukt würde ich das allerdings so schhreiben:

Delphi-Quellcode:

with Adresslist do begin
Add(xxxx);
Add(xxxx);
Add(xxxx);
Add(xxxx);
end;

Entspricht dem gleichen wie in Beispiel 1.

Zitat:

Zitat von Delbor (Beitrag 1368854)

Nach dem Angetroffenen Konstrukt ginge dies offenbar aber auch so:

Delphi-Quellcode:

with Adresslist.Add do begin
y:=xxxx;
y:=xxxx;
fy:=xxxx;
dy:=xxxx;
end;

Ist aber eben nur 1 Instanz von Irgendwas, wo jetzt werte für die Eigenschaften y, y, fy und dy zugewiesen werden

Die Frage ist also, was liefert die Methode Add überhaupt zurück?

Denn ich könnte ja folgendes im Sourcecode von TAddresslist schreiben:

Delphi-Quellcode:

function TAdressList.Add(Name: string): integer;
var
  Adress: TAdress;
begin
  Adress: TAdress.create;
  Adress.Name:=Name;
  self.Add(Adress);
  Result:=self.Count-1;
end;

Jetzt kannst du als AdressList.Add('Willi') ausführen,
aber
With AddressList.Add do
Name:='Willi'

hagelt es eine Exception.

Würde da aber stehen:

Delphi-Quellcode:

function TAdressList.Add(Name: string): TAdress;
var
  Adress: TAdress;
begin
  Adress: TAdress.create;
  Adress.Name:=Name;
  self.Add(Adress);
  Result:=Adress;
end;

dann könnte man so oder so arbeiten.

Entscheidet ist aber immer noch dass jedes Add eine neue Instanz erzeugt.

Delphi-Quellcode:

AdressList.Add('Willi');
AdressList.Add('Willi');
AdressList.Add('Willi');
AdressList.Add('Willi');

Erzeugt 4 Adresseinträge die alle Willi heißen

Aber

Delphi-Quellcode:

with AdressList.Add do 
begin
  Name:='Willi';
  Name:='Willi';
  Name:='Willi';
  Name:='Willi';
end;

Erzeugt 1 Adresseinttrag der Willi heißt.

Es ist also entscheidend die Methode Add aussieht.

Möglicherweise habe ich auch die Frage falsch verstanden.

[Delbor]

Hi Hobbcoder

Zitat:

Ist klar, es werden 4 Instanzen von irgendwas unter AddressList

Nicht von irgendwas, sondern von Strings - hätte ich vielleicht mit anführungszeichen deutlicher schreiben können. Unter '4 Instanzen' verstehe ich hauptsächlich Objektinstanzen,welche mit Create erzeugt werden müssen. Dies ist bei TStrings-'Instanzen' nicht der Fall.

Zitat:

Es ist also entscheidend die Methode Add aussieht.

Ja, das wurde mir inzwischen klar.
Die TCollectionsmethode Add erzeugt ein TCollectionItemsObject und fügt dieser der Collection hinzu.
Die TStringsmethode Add fügt dem TSringsobjekt einen String oder eben auch eine Stringinstanz hinzu, erzeugt dabei allerdings kein neues Objekt (Item ist ein TString).

Zitat:

Möglicherweise habe ich auch die Frage falsch verstanden.

Aus der Fragestellung ging nicht hervor, dass ich die Unterschiede zwischen einer Collection und einer Liste nicht kannte.

Gruss
Delbor

[DeddyH]

Das hat doch nichts mit Liste oder Collection zu tun, sondern rein damit, wie der Rückgabewert (im Bezug auf den Datentyp) der Add-Methode deklariert ist. TKlasse1 und TKlasse2 können ja beide eine Add-Methode besitzen, die aber völlig unabhängig voneinander sind und auch unterschiedliche Typen besitzen können. Anhand des Codes aus dem Ausgangsbeitrag kann es aber IMO nur so sein, dass ein komplexeres Konstrukt, d.h. entweder eine Klasseninstanz, ein Interface oder ein Record, zurückgegeben wird.

[Delbor]

Hi zusammen
@DeddyH:

Zitat:

Das hat doch nichts mit Liste oder Collection zu tun, sondern rein damit, wie der Rückgabewert (im Bezug auf den Datentyp) der Add-Methode deklariert ist.

Tja, wenn ich das jetzt richtig verstanden habe, hat Hobbycoder gezeigt, wie auch eine TStringlist.Add-Methode ein Object zurüchgeben kann.

Gruss
Delbor

[bra]

Ist eine TStringList vielleicht auch eine Liste? :wink:

[DeddyH]

Zitat:

Zitat von Delbor (Beitrag 1368874)

Tja, wenn ich das jetzt richtig verstanden habe, hat Hobbycoder gezeigt, wie auch eine TStringlist.Add-Methode ein Object zurüchgeben kann.

Wo?

[Hobbycoder]

Zitat:

Zitat von DeddyH (Beitrag 1368870)

Das hat doch nichts mit Liste oder Collection zu tun, sondern rein damit, wie der Rückgabewert (im Bezug auf den Datentyp) der Add-Methode deklariert ist.

Das war es, was ich damit klar machen wollte.

Zitat:

Zitat von Delbor (Beitrag 1368874)

Hi zusammen
@DeddyH:

Zitat:

Das hat doch nichts mit Liste oder Collection zu tun, sondern rein damit, wie der Rückgabewert (im Bezug auf den Datentyp) der Add-Methode deklariert ist.

Tja, wenn ich das jetzt richtig verstanden habe, hat Hobbycoder gezeigt, wie auch eine TStringlist.Add-Methode ein Object zurüchgeben kann.

Gruss
Delbor

Wenn die Add-Methode der Klasse TStringList dieses unterstützen würde, sicher. Tut sie aber nicht, sie liefert einen Integer. Hab ich auch nie irgendwo geschrieben.

[Delbor]

Hi DeddyH

Zitat:

Wo?

Hier:

Delphi-Quellcode:

function TAdressList.Add(Name: string): TAdress;
var
  Adress: TAdress;
begin
  Adress: TAdress.create;
  Adress.Name:=Name;
  self.Add(Adress);
  Result:=Adress;
end;

@Hobbycoder:

Zitat:

Wenn die Add-Methode der Klasse TStringList dieses unterstützen würde, sicher. Tut sie aber nicht, sie liefert einen Integer. Hab ich auch nie irgendwo geschrieben.

Was machst du denn anderes, als die von TStringlist geerbte Add-Methode in TAdresslist zu überschreiben?
Okay, das müsste anders formuliert sein:

Zitat:

wie auch eine TStringlist.Add-Methode ein Object zurüchgeben kann.

Stattdessen müsste es wohl heissen:

Zitat:

wie auch in einem TStringlist-Nachkomme eineAdd-Methode ein Object zurüchgeben kann.

Gruss
Delbor

[DeddyH]

Wer sagt denn, dass die TAddressList von TStringList abstammt?

[Delbor]

Hi DeddyH

Zitat:

Wer sagt denn, dass die TAddressList von TStringList abstammt?

Ich, in Antwort 15:

Delphi-Quellcode:

var Adresslist: TStringlist;

Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Adresslist.Add(xxxx);
Das ist definitiv immer die gleiche Instanz und auch immer die gleiche Add-Methode.

Okay,hier verwende ich eine lokale Instanz. So aus dem Stegreif heraus (ich bin mir nicht ganz sicher) müsste ich eine eigene Klasse TAddresslist deklarieren und könnte dann in deren Konstruktor die geerbte Add-Methode überschreiben.

Gruss
Delbor

[DeddyH]

Jetzt wirfst Du aber alles durcheinander. Im gesamten Thread war nie von TStringList die Rede, bis Du damit angefangen hast. Die eingangs gezeigten MapRules jedenfalls sind definitiv keine TStrings oder Nachkommen davon.

[Delbor]

Hi DeddyH

Zitat:

Jetzt wirfst Du aber alles durcheinander. Im gesamten Thread war nie von TStringList die Rede, bis Du damit angefangen hast. Die eingangs gezeigten MapRules jedenfalls sind definitiv keine TStrings oder Nachkommen davon.

Bis ungefähr hierhin hatte ich angenommen, dass Maprules eine Liste ist:

Zitat:

Ich ging eigentlich erstmal auch davon aus, dass Add eine Methode von MapRules ist und war deshalb auch erstaunt, dass das Konstrukt
MapRules.Add(PrecMax := 2); nicht funktionierte.
Daher auch meine Vermutung, dass Add eine Klasse mit dem Property PrecMax sein müsste. Aber eben: wer nennt seine Klasse schon 'Add'??

Und mit der Klasse hatte ich gar nicht so unrecht - nur heisst die nicht 'Add', sondern wird von einer Funktion diesen Namens zurückgegeben. Nur war mir das damals noch nicht wirklich klar, wesshalb ich nach wie vor von einer Liste ausging. Zumindest, bis ich einen lange übersehenen Beitrag entdeckte:

Zitat:

hier, guckt doch einfach in die Wiki :p

Ich hatte zwar darauf aufmerksam gemacht, nur hatte ich übersehen, dass der Link nicht mitkopiert wurde.
Später hatte ich dann wegen dieses Links auf TCollection Bezug genommen und Vergleiche mit TStringlist gemacht.

Denn genau diese und ihre Add-Methode waren es ja, die mich veranlasst hatten, diesen Thread zu eröffnen. Und da lag wohl auch mein Hauptfehler: Im Eingangsbeitrag hätte ich schreiben müssen, dass mit dem in Delphi vordefinierten TStringlist.Add der auskommentierte Code hätte funktionieren müssen.

'tschuldigung :(

Ich hoffe, ich konnte den von mir geknüpften gordischen Knoten nun etwas lösen!

Gruss
Delbor

[Hobbycoder]

Alles gut :-)

Manchmal passiert das eben, dass man mehr oder weniger an einander vorbei redet.
Auch ich hatte in deinem Post#15 überlesen, dass du nun das Beispiel auf TStringList geändert hattest.
Ich bin immer von einer TList oder ToBjectList ausgegangen, weil ich mal angenommen habe, dass TMapRules nicht nur eine einfache StringList ist. Und das wiederum deswegen, weil sowas:

Delphi-Quellcode:

      with MapRules.Add do begin
         PrecMax := 19;
         PrecMin := 4;
         SourceDataType := dtFmtBCD;
         TargetDataType := dtCurrency;
       end;

bei einer StringList so überhaupt nicht funktionieren kann.

[DeddyH]

Nur noch mal zum Abschluss: dieses MapRules (klingt mir sehr nach FireDAC, ich schau aber trotzdem jetzt nicht nach) dürfte sehr wohl eine Liste sein, nur eben keine StringListe, sondern eine Liste von Objekten (oder auch Records oder Interfaces), die mindestens die Eigenschaften PrecMax, PrecMin, SourceDataType und TargetDataType aufweisen. Durch das "with" spart man sich die Deklaration einer eigenen Variablen, erkauft sich das dann aber auch mit schlechter les- und wartbarem Code. Die Alternative habe ich ja bereits auf der ersten Seite aufgezeigt. Und

Zitat:

Delphi-Quellcode:

MapRules.Add(PrecMax := 2);

sieht mir eher nach Basic-Syntax aus, ich kann mir nicht vorstellen, dass das in Delphi in irgendeiner Konstellation kompiliert.

[Delbor]

Hi zusammen

Auch von meiner Seite aus zum Abschluss: TMapRules, bzw TMapRule, sind tatsächlich Firedac-Konstrukte. Ich habe da mal nochmal nachgesehen und bin auch einem Link gefolgt, der TMapRule(s) beschreibt. Und da sind die Deklarationen angegeben:

• TFDMapRules = class(TCollection) und
• TFDMapRule = class (TCollectionItem)

@Hobbycoder:

Zitat:

Ich bin immer von einer TList oder ToBjectList ausgegangen,

Dass dies auch eine ObjectList sein könnte, daran hab ich nun wirlich auch nicht gedacht.

Ein gutes hat die Sache für mich aber doch: Ich werds wohl nicht so schnell vergessen. Auf jeden Fall, vielenDank an euch beide!

Gruss
Delbor