TListView - viele Daten - viel Zeit ...

[mkinzler]

Wenn das Control neu gezeichnet wird. wird der Event pro Item getriggert.

[Sir Rufo]

Ich würde zunächst einmal die Methode aufteilen

1. ListView Columns definieren
   
   Delphi-Quellcode:

   procedure TPostHauptformular.ListViewColumnsPrepare( ALV : TListView; AColumnTextWidth : Integer );
   var
     LColumn : TListColumn;
   begin
     ALV.Columns.BeginUpdate;
     try
       {Alle (alten) Spalten und ListenItems bereinigen.}
       ALV.Columns.clear;
   
       {Memo vorhanden?}
       LColumn := ALV.Columns.add;
       LColumn.Caption := ' ';
       LColumn.Width := AColumnTextWidth; // wo kommt die denn her? Mal als Parameter festgelegt s.o.
   
       {Versanddatum}
       LColumn := ALV.Columns.add;
       LColumn.Caption := 'Datum';
       LColumn.Width := AColumnTextWidth; // wo kommt die denn her? Mal als Parameter festgelegt s.o.
   
       // und noch 4 stück...
   
     finally
       ALV.Columns.EndUpdate;
     end;
   end; {FuelleEintragsliste}

2. ListView Einträge füllen
   
   Delphi-Quellcode:

   procedure TPostHauptformular.FuelleEintragsliste( ALV : TListView; ADataList : TDataList { <- anpassen } );
   var
     NeuerEintrag: TListItem;
     LDataItem : TDataItem; { <- anpassen }
     i : integer;
     s : string;
   begin
     ALV.Items.BeginUpdate;
     try
       ALV.Items.clear;
   
       for i := 0 to AList.letzter do
       begin 
         LDataItem := ADataList[i];
   
         NeuerEintrag := ALV.Items.Add;
         NeuerEintrag.Caption := s; // <- den hast du hoffentlich auch gesetzt
         NeuerEintrag.SubItems.Add( LDataItem.empfaenger );
         NeuerEintrag.SubItems.Add( LDataItem.inhalt );
         // und noch'n paar...
   
       end;
     finally
       Items.EndUpdate;
     end;
   end; {FuelleEintragsliste}

Und diese würde ich auch nicht beide immer ständig aufrufen, sondern nur dann, wenn die benötigt werden. Ist die ListView schon vorbereitet, dann brauche ich die ja nicht noch schon wieder vorbereiten (es ist ja alles da). Und auch wenn man an die Columns geht, dann eben auch dort ein BeginUpdate ... EndUpdate und das auch mit einem try ... finally absichern.

Wenn du eine generellere Methode zum Vorbereiten einer ListView haben möchtest, dann definierst du dir eben:

Delphi-Quellcode:

TColumnDef = record
  Caption : string;
  Width : Integer;
end;

procedure ListViewPrepare( ALV : TListView; AColumnDefs : array of TColumnDef );
var
  LIdx : Integer;
begin
  ALV.Columns.BeginUpdate;
  try
    ALV.Columns.Clear;
    
    for LIdx := Low(AColumnDefs) to High(AColumnDefs) do
    begin
      LColumn := ALV.Columns.Add;
      LColumn.Caption := AColumnDefs[LIdx].Caption;
      LColumn.Width := AColumnDefs[LIdx].Width;
    end;

  finally
    ALV.Columns.EndUpdate;
  end;
end;

Wie man sieht werden die Methoden wesentlich kürzer aber dafür flexibler

[kretabiker]

<OT>@Sir Rufo: Schönes Beispiel für ein gelungenes Refactoring: Durch Struktur Klarheit in den Code gebracht und dann noch eine Generalisierung abgeleitet </OT>

[Sir Rufo]

Nur mal so aus Spaß ... komplett dynamisch

Zwei Listen (Personen, Adressen) werden in einer ListView präsentiert. Klick auf Button1 zeigt die Personen, Klick auf Button2 die Adressen.

Das Umschalten zwischen den beiden Listen benötigt bei 9000 Personen ca. 675ms
Der Refresh der Personen-Liste benötigt bei 9000 Personen ca. 330ms

Das Umschalten zwischen den beiden Listen benötigt bei 10000 Adressen ca. 1065ms
Der Refresh der Adressen-Liste benötigt bei 10000 Adressen ca. 740ms

Hier die ganzen Code-Schnipsel (sollte auch mit Delphi 7 so laufen)

Delphi-Quellcode:

unit FormMain;

interface

uses
  {Winapi.} Windows, {Winapi.} Messages,
  {System.} SysUtils, {System.} Variants, {System.} Classes, {System.} Contnrs,
  {Vcl.} Graphics, {Vcl.} Controls, {Vcl.} Forms, {Vcl.} Dialogs, {Vcl.} StdCtrls, {Vcl.} ComCtrls,

  DataListContainer;

type
  TForm1 = class( TForm )
    ListView1 : TListView;
    Button1 : TButton;
    Button2 : TButton;
    Label1 : TLabel;
    procedure Button1Click( Sender : TObject );
    procedure Button2Click( Sender : TObject );
  private
    FPersons : TObjectList;
    FAddresses : TObjectList;
    FPersonsPresenter : TDataListContainer;
    FAddressPresenter : TDataListContainer;
    procedure ShowInfo( AStart, AStop : TDateTime; ACount : Integer );
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  Form1 : TForm1;

implementation

{$R *.dfm}

uses
  {System.} DateUtils,
  DataListToListView,
  Person, Address;

{ TForm1 }

procedure TForm1.AfterConstruction;
var
  LIdx : Integer;
begin
  inherited;
  // Musterdaten erstellen
  FPersons := TObjectList.Create( True );
  for LIdx := 1 to 3000 do
    begin
      FPersons.Add( TPerson.Create( 'Lustig, Peter', EncodeDate( 1975, 1, 1 ) ) );
      FPersons.Add( TPerson.Create( 'Traurig, Walter', EncodeDate( 1975, 2, 1 ) ) );
      FPersons.Add( TPerson.Create( 'Mustermann, Erika', EncodeDate( 1975, 3, 1 ) ) );
    end;
  
  // Definition der Spalten
  FPersonsPresenter := TDataListContainer.Create;
  FPersonsPresenter.AddColumn( 'Name', 'Fullname', 150 );
  FPersonsPresenter.AddColumn( 'Geburtstag', 'DOB', 80 );
  FPersonsPresenter.DataList := FPersons;

  // Musterdaten erstellen
  FAddresses := TObjectList.Create( True );
  for LIdx := 1 to 2500 do
    begin
      FAddresses.Add( TAddress.Create( 'Am Walde 23', 12345, 'Hinterm Berg' ) );
      FAddresses.Add( TAddress.Create( 'Im Weiher 12', 23456, 'Vordem Berg' ) );
      FAddresses.Add( TAddress.Create( 'Auf der Hecke 5', 34567, 'Beidem Berg' ) );
      FAddresses.Add( TAddress.Create( 'Nebenstollen 5', 45678, 'Unterm Berg' ) );
    end;

  // Definition der Spalten
  FAddressPresenter := TDataListContainer.Create;
  FAddressPresenter.AddColumn( 'Straße', 'Street', 150 );
  FAddressPresenter.AddColumn( 'PLZ', 'ZipCode', 80 );
  FAddressPresenter.AddColumn( 'Ort', 'City', 80 );
  FAddressPresenter.DataList := FAddresses;
end;

procedure TForm1.BeforeDestruction;
begin
  inherited;
  FPersonsPresenter.Free;
  FPersons.Free;
  FAddressPresenter.Free;
  FAddresses.Free;
end;

procedure TForm1.Button1Click( Sender : TObject );
var
  LStart, LStop : TDateTime;
begin
  LStart := Now;
  PresentData( ListView1, FPersonsPresenter );
  LStop := Now;
  ShowInfo( LStart, LStop, FPersonsPresenter.DataList.Count );
end;

procedure TForm1.Button2Click( Sender : TObject );
var
  LStart, LStop : TDateTime;
begin
  LStart := Now;
  PresentData( ListView1, FAddressPresenter );
  LStop := Now;
  ShowInfo( LStart, LStop, FAddressPresenter.DataList.Count );
end;

procedure TForm1.ShowInfo( AStart, AStop : TDateTime; ACount : Integer );
begin
  Label1.Caption := Format( '%d Einträge in %dms', [ACount, MilliSecondsBetween( AStop, AStart )] );
end;

end.

Delphi-Quellcode:

unit Person;

interface

type
  TPerson = class
  private
    FFullname : string;
    FDOB : TDate;
  public
    constructor Create( const Fullname : string; DOB : TDate );
  published
    property Fullname : string read FFullname write FFullname;
    property DOB : TDate read FDOB write FDOB;
  end;

implementation

{ TPerson }

constructor TPerson.Create( const Fullname : string; DOB : TDate );
begin
  inherited Create;
  FFullname := Fullname;
  FDOB := DOB;
end;

end.

Delphi-Quellcode:

unit Address;

interface

type
  TAddress = class
  private
    FStreet : string;
    FZipCode : Integer;
    FCity : string;
  public
    constructor Create( const Street : string; ZipCode : Integer; const City : string );
  published
    property Street : string read FStreet write FStreet;
    property ZipCode : Integer read FZipCode write FZipCode;
    property City : string read FCity write FCity;
  end;

implementation

{ TAddress }

constructor TAddress.Create( const Street : string; ZipCode : Integer; const City : string );
begin
  inherited Create;
  FStreet := Street;
  FZipCode := ZipCode;
  FCity := City;
end;

end.

Delphi-Quellcode:

unit DataListContainer;

interface

uses
  Contnrs;

type
  TDataColumnDef = record
    Caption : string;
    PropertyName : string;
    Width : Integer;
    Visible : Boolean;
  end;

  TDataColumnDefs = array of TDataColumnDef;

  TDataListContainer = class
  private
    FDataList : TObjectList;
    FColumnDefs : TDataColumnDefs;
  public
    procedure AddColumn( ACaption, APropertyName : string; AWidth : Integer; AVisible : Boolean = true );

    property ColumnDefs : TDataColumnDefs read FColumnDefs;
    property DataList : TObjectList read FDataList write FDataList;
  end;

implementation

{ TDataListContainer }

procedure TDataListContainer.AddColumn( ACaption, APropertyName : string; AWidth : Integer; AVisible : Boolean );
var
  LIdx : Integer;
begin
  LIdx := Length( FColumnDefs );
  SetLength( FColumnDefs, LIdx + 1 );
  FColumnDefs[LIdx].Caption := ACaption;
  FColumnDefs[LIdx].PropertyName := APropertyName;
  FColumnDefs[LIdx].Width := AWidth;
  FColumnDefs[LIdx].Visible := AVisible;
end;

end.

Delphi-Quellcode:

unit DataListToListView;

interface

uses
  {Vcl.} ComCtrls,
  DataListContainer;

procedure PresentData( AListView : TListView; AContainer : TDataListContainer );
procedure PrepareColumns( AListView : TListView; AContainer : TDataListContainer );
procedure FillData( AListView : TListView; AContainer : TDataListContainer );

implementation

uses
  {System.} TypInfo;

procedure PresentData( AListView : TListView; AContainer : TDataListContainer );
begin
  PrepareColumns( AListView, AContainer );
  FillData( AListView, AContainer );
end;

procedure PrepareColumns( AListView : TListView; AContainer : TDataListContainer );
var
  LCount : Integer;
  LIdx : Integer;
  LColumn : TListColumn;
begin
  AListView.Columns.BeginUpdate;
  try

    LCount := Length( AContainer.ColumnDefs );

    // Spalten hinzufügen, wenn nicht ausreichend vorhanden
    while AListView.Columns.Count < LCount do
      AListView.Columns.Add;

    for LIdx := 0 to AListView.Columns.Count - 1 do
      begin
        LColumn := AListView.Columns.Items[LIdx];
        if LIdx < LCount
        then
          begin
            LColumn.Caption := AContainer.ColumnDefs[LIdx].Caption;
            if AContainer.ColumnDefs[LIdx].Visible
            then
              LColumn.Width := AContainer.ColumnDefs[LIdx].Width
            else
              LColumn.Width := 0;
          end
        else
          begin
            LColumn.Caption := '';
            LColumn.Width := 0;
          end;
      end;

  finally
    AListView.Columns.EndUpdate;
  end;
end;

procedure FillData( AListView : TListView; AContainer : TDataListContainer );
var
  LIdx : Integer;
  LCount : Integer;
  LItem : TListItem;
  LDataItem : TObject;
  LColIdx : Integer;
  LColCount : Integer;
  LPropValue : string;
begin
  AListView.Items.BeginUpdate;
  try

    if Assigned( AContainer.DataList )
    then
      LCount := AContainer.DataList.Count
    else
      LCount := 0;

    if AListView.Items.Count - LCount > LCount
    then
      AListView.Items.Clear;

    // Zeilen hinzufügen, wenn nicht ausreichend vorhanden
    while AListView.Items.Count < LCount do
      AListView.Items.Add;

    // Zeilen entfernen, wenn zuviel
    while AListView.Items.Count > LCount do
      // Löschen immer vom Ende her, das spart Zeit
      AListView.Items.Delete( AListView.Items.Count - 1 );

    for LIdx := 0 to LCount - 1 do
      begin
        LItem := AListView.Items[LIdx];
        LDataItem := AContainer.DataList.Items[LIdx];
        LColCount := Length( AContainer.ColumnDefs );

        // SubItems
        LItem.SubItems.BeginUpdate;
        try
          LItem.SubItems.Clear;

          for LColIdx := 0 to LColCount - 1 do
            begin
              LPropValue := GetPropValue( LDataItem, AContainer.ColumnDefs[LColIdx].PropertyName, True );

              if LColIdx = 0
              then
                // Caption
                LItem.Caption := LPropValue
              else
                LItem.SubItems.Add( LPropValue );

            end;

        finally
          LItem.SubItems.EndUpdate;
        end;
      end;

  finally
    AListView.Items.EndUpdate;
  end;
end;

end.

[Marco Steinebach]

Hallo,
joa, das ist doch mal ein Beispiel! wow!!
Mein Code macht, dem Grunde nach, das Gleiche - ich hab natürlich das try-except nicht drin - und das hier kannstde natürlich allgemeiner verwenden.

Meine Prozedur zum Füllen der Liste wird nur einmal aufgerufen, oder per Hand, zum Aktualsisieren der Ansicht.
Und da das Befüllen mit ca. 530 Zeilen knapp 800 ms dauert, wollte ich's ein bißchen schneller haben.
Deshalb kam ich ja auch auf die Idee, OwnerData auf true zu setzen, ich hänge aber immernoch daran, daß er OnData so oft aufruft, selbst wenn ich das Programm komplett in Ruhe lasse, also, denke ich, nix neu gezeichnet werden muß.
Vielleicht hat ja doch noch jemand einen Tipp, sonst muß ich eben mit den 800 ms leben.
Was ich, fällt mir gerade ein, noch nicht ausprobiert habe ist, die Zeilen zunächst anzulegen, und dann indiziert zu füllen - wie in deinem Beispiel - wer weiß, ob das nochwas bringt...

Viele Grüße
Marco

[Sir Rufo]

Schau dir deinen Code nochmal genauer an.

Du rufst Items.Clear auf, obwohl du noch nicht Items.BeginUpdate aufgerufen hast.

Mach das und du wirst sehen, dass es schneller geht.

Das Wiederverwenden der ListItems spart auch noch eine Menge Zeit ein.

[jaenicke]

Auch hier poste ich einmal den Hinweis auf die VirtualTreeView:
http://www.jam-software.com/virtual-treeview/
Darin haben wir durchaus auch hunderttausende Einträge, die innerhalb weniger Millisekunden angezeigt werden. Oder z.B. 10000 Einträge, die absolut live bei der Eingabe eines Filters gefiltert werden.

Ich probiere heute Abend einmal das Beispiel von Sir Rufo darin aus.

[p80286]

Könnte man den Thread nach Tutorial oder die CodeLibrary verschieben?

Gruß
K-H

[jaenicke]

So, ich habe es nur ganz kurz gemacht, eigentlich könnte man das noch deutlich schöner machen. Ergebnisse jedenfalls:
Das Umschalten zwischen den beiden Listen benötigt bei 9000 Personen ca. 2ms
Der Refresh der Personen-Liste benötigt bei 9000 Personen ca. 2ms

Das Umschalten zwischen den beiden Listen benötigt bei 10000 Adressen ca. 2ms
Der Refresh der Adressen-Liste benötigt bei 10000 Adressen ca. 2ms

Das Projekt liegt im Anhang.

Füge ich die Daten direkt in die Knoten als Daten ein, dauern die Operationen ca. 10ms. Sprich anders als im Anhang:

Delphi-Quellcode:

procedure FillData(AListView: TVirtualStringTree; AContainer: TDataListContainer);
var
  i: Integer;
begin
  AListView.BeginUpdate;
  try
    AListView.Clear;
    if Assigned(AContainer.DataList) then
      for i := 0 to AContainer.DataList.Count - 1 do
        AListView.AddChild(nil, AContainer.DataList[i]);
  finally
    AListView.EndUpdate;
  end;
end;

Und:

Delphi-Quellcode:

procedure TForm6.VirtualStringTree1GetText(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Column: TColumnIndex; TextType: TVSTTextType;
  var CellText: string);
var
  CurrentEntry: TObject;
begin
  CurrentEntry := TObject(Sender.GetNodeData(Node)^);
  if CurrentEntry is TPerson then
...

[Marco Steinebach]

Zitat von Sir Rufo:

...Du rufst Items.Clear auf, obwohl du noch nicht Items.BeginUpdate aufgerufen hast.

Mach das und du wirst sehen, dass es schneller geht.

jawoll, und wie ich das sehe! Dauert nur noch knapp die Hälfte an Zeit.
Meine Güte, manchmal programmiert man sich einen Mist zusammen, wie kann man denn erst Clear und dann BeginUpdate aufrufen ...
Vielen Dank!

Zitat von Sir Rufo:

Das Wiederverwenden der ListItems spart auch noch eine Menge Zeit.

Das kommt als nächstes - mal sehen wieviel es bringt...

Ich schau mir jetzt mal VirtualTreeview an - wenn das Ergebnis mit Screenreader gut auszulesen ist - warum nicht wechseln...

So hat sich auch, schlicht weil's nicht nötig ist, das Problem mit dem OwnerData gelöst .

Viele Grüße und ganz herzlichen Dank!
Marco