Dateiauslesezugriff beschleunigen

[Saulmann]

Guten Morgen liebe Community,

ich arbeite zur Zeit mit XML-Dateien, welche ich mittels XML-Binding in mein Projekt einbinde.
Sämtliche Daten die in der XML gefunden werden, möchte ich in einem Record speichern. Dabei geht es mir nicht darum wie ich die Daten aus dem XML-File auslese, sondern wie ich das Auslesen beschleunigen kann.

Sprich, ich habe eine XML-Datei die mehrere Möbelstücke enthält. Jedes Möbelstück hat eine Kennnummer, einen Namen und einige Maße, die die Größe des Möbelstücks beschreiben. Jedes Möbelstück besteht aus mehreren Teilen/Komponenten, die ebenfalls Kennnummern, Namen und Maße besitzen.

Code:

<?xml version='1.0' encoding='UTF-8'?>
<datenbank>
  <komponente nr'1' name='schrankwand' hoehe='200' breite='60' tiefe='3' />
  <komponente nr'2' name='schranktuer' hoehe='200' breite='50' tiefe='3' />
  ...
  
  <moebelstueck nr='1' name='schrank' hoehe='200' breite='100' tiefe='60'>
    <teilkomponente nr='1' />
    <teilkomponente nr='1' />
    <teilkomponente nr='2' />
    <teilkomponente nr='2' />
    <teilkomponente nr='6' />
    <teilkomponente nr='7' />
    <teilkomponente nr='8' />
  </moebelstueck>
  <moebelstueck nr='2'
    ...

</datenbank>

Möbelstücke und Komponenten werden in der XML separat aufgezählt.
Folglich möchte ich Jedes Möbelstück, dessen Daten und die dazugehörigen Komponenten in einem Record zusammenfassen (TMoebelStueck). Das Record soll nicht nur die Eigenschaften des Möbelstücks enthalten, sondern auch die Daten der dazugehörigen Komponenten.
Dazu habe ich ein entsprechendes Record für die Möbelstücke erstellt. Das zu beschreibende Record enthält einfache Variablen und außerdem noch ein weiteres Record, um die Beziehungen zwischen Komponenten/Teilkomponenten und Möbelstück festzuhalten.

Delphi-Quellcode:

type
  TMoebelKomponente = record
    nr: Integer;
    name: string;
    hoehe: double;
    tiefe: double;
    breite: double;
  end;

  TMoebelStueck = record
    nr: Integer;
    name: string;
    hoehe: double;
    tiefe: double;
    breite: double;
    komponente: array of TMoebelKomponente;
  end;

Mit folgendem Code lese ich sämtliche Daten aus der XML und speichere alle Daten eines Möbelstücks und die dazugehörigen Komponenten im Record.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  moebelArray: array of TMoebelStueck;
  i, k, m: Integer;
begin
  SetLength(moebelArray, datenbank.moebel.Count);

  for i := 0 to datenbank.moebel.Count - 1 do     // hohle alle Möbel und speichere deren Daten
  begin
    moebelArray[i].nr := OSM.Way[i].nr;
    moebelArray[i].name := OSM.Way[i].name;
    moebelArray[i].hoehe := OSM.Way[i].hoehe;
    moebelArray[i].breite := OSM.Way[i].breite;
    moebelArray[i].tiefe := OSM.Way[i].tiefe;
      
    SetLength(moebelArray[i].komponente, datenbank.moebel[i].teilkomponente.Count);

    for k := 0 to datenbank.moebel[i].teilkomponente.Count - 1 do     
    begin
      moebelArray[i].komponente[k].nr := datenbank.moebel[i].teilkomponente.Items[k].nr;     // lese alle Kennnummern der zum Möbelstück gehörigen Komponenten aus

      for m := 0 to datenbank.komponente.Count - 1 do     // ordne einer Kennnummer alle entsprechenden Eigenschaften der Komponenten zu
        if datenbank.moebel[i].teilkomponente.Items[k].nr = datenbank.komponente[m].nr then
        begin
          moebelArray[i].komponente[k].name := datenbank.komponente[m].name;
          moebelArray[i].komponente[k].breite := datenbank.komponente[m].breite;
          moebelArray[i].komponente[k].hoehe := datenbank.komponente[m].hoehe;
          moebelArray[i].komponente[k].tiefe := datenbank.komponente[m].tiefe;
        end;
    end;
  end;
end;

Soweit so gut. Funktioniert ja auch alles, nur die benötigte Zeit zum Auslesen der Daten ist ein wenig hoch. Das liegt hautsächlich an der dritten for-Schleife. Da gleiche ich alle vorhandenen Kennnummern der Komponenten (die in der XML stehen) mit den Kennnummern der Teilkomponenten eines Möbelstücks ab. Und das für jede Teilkomponente. Die Folge ist eine hohe Rechenzeit. Anzahl der Durchläufe = Komponente * Teilkomponente
Gibt es zufällig noch eine andere Möglichkeit die Zuordnung zu realisieren, um möglichst viel Zeit zu sparen?

Gruß,
Saul

[jaenicke]

Guten Morgen!

Ich würde die Daten stattdessen in ein TDictionary<Integer, TMoebelStueck> packen. Dann kannst du die Nummern direkt als Schlüssel benutzen und musst nicht das Array durchlaufen um diese zu suchen.

Bei der Gelegenheit würde ich auch gleich auf TObjectDictionary gehen und Klassen verwenden. Dann brauchst du die Daten der Komponenten gar nicht zu kopieren, sondern brauchst nur einen Pointer darauf oder auch nur die Nummer, da du ja jederzeit schnell an die Werte herankommst.

Sprich:

Delphi-Quellcode:

  TFurnitureItem = class
  private
    FNumber: Integer;
    FName: string;
    FHeight: Double;
    FDepth: Double;
    FWidth: Double;
    FComponentNumbers: TList<Integer>;
    FComponents: TList<TFurnitureItem>;
  public
    constructor Create; // zum Erzeugen der Listen
    destructor Destroy; override; // zum Freigeben
    property Number: Integer read FNumber write FNumber;
    property Name: string read FName write FName;
    property Height: double read FHeight write FHeight;
    property Depth: double read FDepth write FDepth;
    property Width: double read FWidth write FWidth;
    property ComponentNumbers: TList<Integer> read FComponentNumbers;
    property Components: TList<TFurnitureItem> read FComponents; // eigentlich gar nicht notwendig
  end;

Oder eben Array of Integer und ganz ohne direkte Zuordnung.

Und dann sowas:

Delphi-Quellcode:

var
  FurnitureList: TObjectDictionary<Integer, TFurnitureItem>;
  NewItem, CurrentItem: TFurnitureItem;
  i: Integer;
begin
  FurnitureList := TObjectDictionary<Integer, TFurnitureItem>.Create([doOwnsValues]);
  try
    for i := 0 to datenbank.moebel.Count - 1 do // hole alle Möbel und speichere deren Daten
    begin
      NewItem := TFurnitureItem.Create;
      NewItem.Number := OSM.Way[i].nr;
      NewItem.Name := OSM.Way[i].name;
      NewItem.Height := OSM.Way[i].hoehe;
      NewItem.Width := OSM.Way[i].breite;
      NewItem.Depth := OSM.Way[i].tiefe;
      for k := 0 to datenbank.moebel[i].teilkomponente.Count - 1 do 
        NewItem.ComponentNumbers.Add(datenbank.moebel[i].teilkomponente.Items[k].nr);

      FurnitureList.Add(NewItem.Number, NewItem);
    end;
    // Jetzt kannst du, wenn du möchtest, die Komponenten auch zuweisen (jetzt sind ja alle da)
    // Eigentlich reichen aber auch die Nummern
    for CurrentItem in FurnitureList do 
      for i := 0 to CurrentItem.ComponentNumbers.Count - 1 do
        CurrentItem.Components.Add(FurnitureList[CurrentItem.Number]);

    // mach was mit der Liste...

  finally
    FurnitureList.Free;
  end;

Willst du nun ein Item zu einer Nummer reicht FurnitureItem[DeineNummer], prüfen ob es existiert kannst du mit FurnitureItem.Contains, ...