Results 1 to 6 of 6

Thread: generic list

  1. #1

    generic list

    Hallo allemaal ik heb een generic list gemaakt van een eigen type zij onderstaande pseudo code
    Code:
    Titems =  record
     item1:integer;
     item2:string;
     item3:integer;
    end
    
    DataItems:Tlist<Titems>;
    TempItem:Titems;
    
    
    DataItems:=Tlist<Titems>.create;
    TempItem.item1:=10;
    TempItem.item2:='A';
    TempItem.item3:=30;
    DataItems.add(TempItem);
    Op deze manier kan ik mijn datalijst prima vullen.
    Wanneer ik nu meerdere entires heb kan ik prima met een loop je door mijn data heen.
    De vraag is nu kan ik ook met een loopje de items heen zodat ik niet steeds item1, item2, item3 hoef uit te schrijven.

    Ik hoor graag of dit mogelijk is

  2. #2
    mov rax,marcov; push rax marcov's Avatar
    Join Date
    Apr 2004
    Location
    Ehv, Nl
    Posts
    10,357
    Niet op een zinnige manier. Er is RTTI maar dat is meer iets voor diep in frameworks.

    Een praktische oplossing is simpelweg een setter definiëren die de relevante items zet. Dus als je vaak 1, 2 en 4 zet krijg je iets als

    Delphi Code:
    1. Titems =  record
    2.  item1:integer;
    3.  item2:string;
    4.  item3:integer;
    5.  item4:char;
    6.  procedure setzinnigenaamvoor124(anitem1:integer;anitem2:string;anitem4:char);
    7. end
    8.  
    9.  
    10.  procedure TItems.setzinnigenaamvoor124(anitem1:integer;anitem2:string;anitem4:char);
    11.  begin
    12.     item1:=aniitem1;     item2:=aniitem2;     item4:=aniitem4;
    13.  end;

    enz

  3. #3
    Bedankt voor je antwoord.

    Voor het zetten van de variablen had ik al een functie geschreven waarbij je de afzonderlijke items op moest geven en het resultaat is dat je ingevulde record.
    Maar waar ik eigenlijk op zoek naar ben is ofg ik met een for loop door de items kan lopen
    Code:
    for i:=0 to dataitems.count-1 do
    begin
     for j:=0 to dataItems[i].itemcount -1 do
     begin
      dataItems[i].item[j]:= ....
     end;
    
    end;

  4. #4
    mov rax,marcov; push rax marcov's Avatar
    Join Date
    Apr 2004
    Location
    Ehv, Nl
    Posts
    10,357
    Zoals gezegd kan dat wel, maar dan moet je je verdiepen in RTTI. Er zijn daar twee versies van, eentje (de klassieke) voor published properties van classes, en de andere (D2010+) voegt ook RTTI toe aan gewone symbolen (zoals records) en andere visibilities.

    Ik heb daar echter geen voorbeeld van, dus ff in de help duiken. Let op zoals gezegd zijn dat oplossingen voor diep in frameworks, (de lus wordt lang en gecompliceerd vanwege de mogelijke verschillende types enz). Dit is geen "gemaks" oplossing.

  5. #5
    Ik vraag me af wat je met dat loopje kan, tenzij dataItems[i] een variant is (of bevat).

    Het uitschrijven met RTTI is dan denk ik vooral ook handig als je een soort mapper wilt schrijven die een generieke lijst van dataitems (of wellicht zelfs een dataset), kan mappen naar een specifiek opgegeven record. Er zijn wel JSON- of andere mappers te vinden die al een soortgelijk trucje doen. Je zou bijvoorbeeld eens naar Marshmallow kunnen kijken. Volgens mij werkt dat ook ongeveer op die manier.

    Als je alleen dat ene record hebt, dan is het denk ik de moeite niet waard, en zou ik het gewoon in een functie proppen zoals je nu gedaan hebt.
    1+1=b

  6. #6
    Als je types van je items niet gelijk zijn is het m.i. een beetje onlogisch om er abstract overheen te willen itereren. Maar je zou inderdaad een Variant of een TValue (uit System.RTTI) kunnen gebruiken.

    Dan kun je van de items ook weer een generic list maken. Of een dictionary, als je het itemnummer wilt storen. Overigens is het dan wel makkelijker om van TItems een class te maken.

    Delphi Code:
    1. TItems = class
    2. private
    3.   FItems: TDictionary<Integer, TValue>;
    4. public
    5.   constructor Create;
    6.   destructor Destroy; override;
    7.  
    8.   property Item: TDictionary<Integer, TValue> read FItems write FItems;
    9. end;
    10.  
    11. constructor TItems.Create;
    12. begin
    13.   FItems := TDictionary<Integer, TValue>.Create;
    14. end;
    15.  
    16. destructor TItems.Destroy;
    17. begin
    18.   FItems.Free;
    19. end;
    20.  
    21. // ...
    22.  
    23. Items := TItems.Create;
    24.  
    25. for i := 0 to DataSet.RecordCount - 1 do
    26. begin
    27.   Value := TValue.From(Dataset.FieldByName('item' + i.ToString).Value);
    28.   Items.Item.Add(i, Value);
    29. end;

    En als je het echt via RTTI wilt is dit een aardige start: http://www.drbob42.com/uk-bug/hood-01.htm

Thread Information

Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •