Delphi-PRAXiS - Delphi FileStream.WriteBuffer für binäre Daten in einem String

Servus und Hallo,

der Titel klingt schon gruselig, aber bevor ich hier zerrissen werde, lasst mich erklären, was es damit auf sich hat. Wir verwenden hier Client/Server-Applikationen, die über ClientDatasets/DataProvider miteinander kommunizieren. Über spezifische DataRequests erhalten wir Daten in einer Key/Value-StringList. Alles andere erfolgt unmittelbar über die Anbindung an die Datenbank.

Bislang haben wir, wenn wir Logdateien von Kundenrechnern zur Auswertung von Fehlern oder der allgemeinen Performance benötigten, eine Netzwerkverbindung zum Kundenserver aufgebaut und die Dateien mittels Windows zu uns kopiert. Dank Conficker, der sich auch über diese Ports verbreiten konnte, halten unsere Admins nun diese Ports geschlossen, dennoch benötigen wir immer wieder diese Dateien.

Nun ja, mein Ansatz ist nun, die Dateien auch über einen DataRequest zu kopieren. Auf Server-Seite öffne ich die Datei mittels FileStream, lese einen Block (Chunk) ein und schicke diesen mit dem DataRequest zurück an den Client, der schreibt die Daten in einen eigenen FileStream und das geschieht so lange, bis die komplette Datei gelesen ist.

Das Einlesen gelingt ohne Probleme:

Delphi-Quellcode:

			procedure TMyDataModule.do_DRQ_CopyFile(const aCommand: String; const aParameters: TStringList; const aResult: TStringList);

var

  loc_fs: TFileStream;

  loc_s: String;

  loc_s2: String;

  loc_i: Integer;

  loc_chunk: Integer;

begin

  aResult.Values[aCommand] := 'F';

  loc_fs := TFileStream.Create(aParameters.Values['FileName'], fmOpenRead or fmShareDenyWrite);

  try

    aResult.Values['FileSize'] := IntToStr(loc_fs.Size);

    loc_fs.Seek(StrToIntDef(aParameters.Values['Position'], 0), soFromBeginning);

    loc_chunk := loc_fs.Size - loc_fs.Position;

    if (64 * ONE_KILOBYTE < loc_chunk) then

      loc_chunk := 64 * ONE_KILOBYTE;

    SetLength(loc_s, loc_chunk);

    loc_fs.Read(loc_s[1], loc_chunk);

    aResult.Values['BytesRead'] := IntToStr(loc_chunk);

    { Erste Möglichkeit: Kopieren als String }

    aResult.Values['Data'] := loc_s;

    { Zweite Möglichkeit: Kopieren der ASCII-Werte }

//    for loc_i := 1 to loc_chunk do

//      loc_s2 := loc_s2 + IntToStr(Ord(loc_s[loc_i])) + ';';

//    loc_s2 := Copy(loc_s2, 1, Length(loc_s2) - 1);

//    aResult.Values['Data'] := loc_s2;

    aResult.Values[aCommand] := 'T';

  finally

    FreeAndNil(loc_fs);

  end;

end;

Möglichkeit 1 war mein ursprünglicher Plan, der verursacht aber auf der Client-Seite Probleme, auf die ich später eingehe.
Möglichkeit 2 umgeht das Problem mit den im String "gespeicherten" Steuerzeichen, ist aber unglaublich zeitaufwändig.

Auf Clientseite sieht das dann wie folgt aus:

Delphi-Quellcode:

			function TLogBrowser.DownloadDRQ: Boolean;

var

  loc_fs: TFileStream;

  loc_Position: Integer;

  loc_FileSize: Integer;

  loc_drq: String;

  loc_v: Variant;

  loc_sl: TStringList;

  loc_Result: Boolean;

begin

  FCancelled := False;

  loc_sl := TStringList.Create;

  try

    loc_FileSize := 0;

    loc_Position := 0;

    if FileExists(GetTempDir + ExtractFileName('C:\DummyFile.txt')) then

      loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmOpenWrite)

    else

      loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmCreate);

    try

      loc_fs.Seek(0, soBeginning);

      repeat

        loc_drq := 'CMD=' + DRQ_CopyFile + ',' +

                   'FileName=' + 'C:\DummyFile.txt' + ',' +

                   'Position=' + IntToStr(loc_Position);

        loc_v := cdsFiles.DataRequest(loc_drq);

        loc_Result := DataRequestResult(DRQ_CopyFile, loc_v, loc_sl);

        if (loc_Result) then begin

          loc_FileSize := StrToIntDef(loc_sl.Values['FileSize'], 0);

          loc_fs.WriteBuffer(Pointer(loc_sl.Values['Data'])^, StrToIntDef(loc_sl.Values['BytesRead'], 0));

          Inc(loc_Position, StrToIntDef(loc_sl.Values['BytesRead'], 0));

        end;

      until (not loc_Result) or (loc_Position >= loc_FileSize);

    finally

      FreeAndNil(loc_fs);

    end;

  finally

    FreeAndNil(loc_sl);

  end;

  Result := loc_Result;

end;

Bei dieser Variante scheint zunächst alles zu funktionieren, aber: beim Schreiben des FileStreams werden ab dem ersten Zeilenumbruch oder dem ersten #0 Zeichen nur noch #0 Zeichen geschrieben. Dadurch sind die "kopierten" Daten natürlich vollkommen "wertlos".

Bei der zweiten Variante, bei der ich die ASCII- Werte übertrage, funktioniert zwar alles wie geplant, aber es ist seeeeeeeeehr zeitraubend. (2 MB benötigen dann knapp 30 Sekunden).

Delphi-Quellcode:

			function TLogBrowser.DownloadDRQ: Boolean;

var

  loc_j: Integer;

  loc_fs: TFileStream;

  loc_Position: Integer;

  loc_FileSize: Integer;

  loc_drq: String;

  loc_buffer: array [0.. 64 * ONE_KILOBYTE] of Byte;

  loc_sl2: TStringList;

  loc_v: Variant;

  loc_sl: TStringList;

  loc_Result: Boolean;

begin

  FCancelled := False;

  loc_sl := TStringList.Create;

  try

    loc_FileSize := 0;

    loc_Position := 0;

    if FileExists(GetTempDir + ExtractFileName('C:\DummyFile.txt')) then

      loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmOpenWrite)

    else

      loc_fs := TFileStream.Create(GetTempDir + ExtractFileName('C:\DummyFile.txt'), fmCreate);

    try

      loc_fs.Seek(0, soBeginning);

      loc_sl2 := TStringList.Create;

      try

        repeat

          loc_drq := 'CMD=' + DRQ_CopyFile + ',' +

                     'FileName=' + 'C:\DummyFile.txt' + ',' +

                     'Position=' + IntToStr(loc_Position);

          loc_v := cdsFiles.DataRequest(loc_drq);

          loc_Result := DataRequestResult(DRQ_CopyFile, loc_v, loc_sl);

          if (loc_Result) then begin

            loc_FileSize := StrToIntDef(loc_sl.Values['FileSize'], 0);

            StrToStrings(loc_sl.Values['Data'], CON_FieldSep, loc_sl2, False);

            for loc_j := 0 to loc_sl2.Count - 1 do

              loc_buffer[loc_j] := StrToInt(loc_sl2[loc_j]);

            loc_fs.WriteBuffer(loc_buffer, StrToIntDef(loc_sl.Values['BytesRead'], 0));

            loc_fs.WriteBuffer(Pointer(loc_sl.Values['Data'])^, StrToIntDef(loc_sl.Values['BytesRead'], 0));

            Inc(loc_Position, StrToIntDef(loc_sl.Values['BytesRead'], 0));

          end;

        until (not loc_Result) or (loc_Position >= loc_FileSize);

      finally

        FreeAndNil(loc_sl2);

      end;

    finally

      FreeAndNil(loc_fs);

    end;

  finally

    FreeAndNil(loc_sl);

  end;

  Result := loc_Result;

end;

Die Hilfsfunktion DataRequestResult schreibt den Inhalt der Variant-Variable in eine Key/Value-StringList und wertet das Ergebnis des Paares mit dem Namen der DataRequest-Konstante aus. Wenn dieses 'T' ist, gibt die Funktion True zurück.

Die Hilfsfunktion StrToStrings stammt aus der JCL-Library. Sie wandelt einen String in eine Stringliste um. Dabei wird der übergebene Separator als Trennzeichen genutzt.

Delphi-Quellcode:

			procedure StrToStrings(S: String; Sep: String; const List: TStrings; const AllowEmptyString: Boolean);
		

Hat von Euch jemand eine Idee, was in der ersten Variante verbessert werden kann, so dass diese nutzbar wird? Oder einen Vorschlag, was ich verändern kann, um die zweite Variante drastisch zu beschleunigen? (Ich habe schon mit unterschiedlich großen Datenmengen gearbeitet, was aber kaum einen Unterschied bewirkte).

Vielen Dank schon einmal im Voraus

C.