MemoryStream Bearbeitung optimieren

[alleinherrscher]

Hi Leute!

Ich bastle gerade an einem Programm, welches per Indy Memorystreams verschicken kann. Ich hab mir hierfür nen eigenen Datentyp (Record) gebastelt, der aus 2 Strings besteht (wo man z.B. Dateinamen einer Datei oder irgendwelche Informationen über den Stream etc. reinschreiben kann) und einem Memorystream, der die Daten selbst enthält.

Um diesen Datentyp zu verschicken, bastle ich mir n neuen Memorystream zum versenden, der am Anfang den Inhalt der Strings hat, und dann per copyfrom die daten des ursprünglichen Memorystreams aus dem Datentyp bekommt.

Da ich das programm auf mehrere einzelne Prozeduren aufgeteilt hab, in denen der Memorystream als parameter übergeben wird, wird die bearbeitung von datenmengen >20mb sehr lang-weilig ;) also das dauert dann schonmal 30 sekunden oder so.




Jetzt meine Frage: kann man anstatt des Memorystreams auch den Pointer des Streams als Parameter übergeben, oder macht Delphi das automatisch? Ich hab nämlich so das gefühl, dass der Intern jedes mal den kompletten Stream kopiert, wenn man ihn als Parameter übergibt.


Danke und schöne grüße an alle!

[Bernhard Geyer]

Wenn Du TMemoryStream oder eine ableitung davon verwendest wird bei einer übergabe in einer Funktion/Methode eh nur der Zeiger/Referenz übergeben. Das Problem muss also woanders liegen.

[alleinherrscher]

Danke für die schnelle Antwort! Kann es dann an der Funktion TMemorystream.CopyFrom liegen? Sollte man große Memorystreams besser nicht kopieren?

Ich glaube ich füge besser mal etwas Code dazu:

Delphi-Quellcode:

//Es geht los mit:

stream2:=TMemorystream.Create;
stream2.LoadFromFile(edit1.text);


//Als nächstes wird mein Datentyp zusammengebaut:
function Packagebuilder(packagetype:TMEINPACKETTYP;stream2:TMemorystream;str:,additional:string):TMEINPACKET;

pack.packagetype:=packagetype;
pack.data:=stream2;          //hier wird also der oben erzeugte stream2 in meinen Datentyp eingebaut
pack.additional:=additional;
pack.str:=str;
result:=pack;
end;


//Nun wollen wir den Datentyp per Indy verschicken und bauen dafür einen Stream der per Indy 
//verschickt werden kann: (wir rufen also SendPackage mit dem Argument pack von oben auf)

procedure SendPackage(pack:TMEINPACKET;Host:String);

var stream : TMemoryStream; inttype,len:integer;
begin

stream := TMemorystream.Create;

//Schreibt Typ des Packages in den Stream:
inttype:=packagetypetoint(pack.packagetype);
stream.Write( inttype, SizeOf( inttype ) );

//Schreibt Inhalt der String Pointer in Filestream mit Längenangabe
len := Length( pack.str );
stream.Write(len, SizeOf(len) );
stream.Write( PChar(pack.str)^, len );

len := Length( pack.additional );
stream.Write(len, SizeOf(len) );
stream.Write( PChar(pack.additional)^, len );

//Schreibt Data Stream in den zu versendenden Stream
stream.Position:=stream.Size;
stream.CopyFrom(pack.data,0);

//Verschickt den Stream per Indy
sendstream(stream,Host);

end;

Kann mir jemand sagen was hier so zeitraubend ist?

[alleinherrscher]

Update: Ich habe gerade den bösewicht ausgemacht:

es ist in der tat das Copyfrom was so viel zeit in anspruch nimmt....

Habt ihr evtl n tip wies schneller gehen könnte?

[KingIR]

Wenn du den ersten Stream (den den du aus der Datei geladen hast und von dem du dann mit CopyFrom() kopierst) nicht noch anderweitig brauchst, kannst du doch in den vorne dran einfach noch die Daten (Länge usw.) schreiben und ihn dann versenden.
Hab es nicht getestet, aber vielleicht geht es ja schneller :drunken:

[alleinherrscher]

Hey, KingIR!

Die Idee ist klasse - Danke!
Das würde sogar den Speicheraufwand verringern! Blöde frage nur: Wie schreibe ich an den Anfang eines Streams *confused* :)

[KingIR]

Ganz einfach,

Delphi-Quellcode:

Stream.Position := 0;
Stream.Write(...);

[alleinherrscher]

Überschreibt er dann nicht die alten Daten?

//edit: Und dann stellt sich hinterher auch noch die Frage: Wie lösche ich wieder Daten am anfang eines Streams ;)

[KingIR]

Mist, stimmt natürlich :wall:

Die einzige Alternative, die mir so nocht einfällt, wäre dann, anstelle des ersten Streams den Dateiname an die Funktion zu übergeben, die dann erstmal den Header (Größe usw.) in den Stream schreibt und dann mit BlockRead die Datei einliest und in den Stream schreibt. Weiß nicht ob du nur Daten aus Dateien lesen möchtest, aber falls ja, dann wäre das meine Lösung.

Delphi-Quellcode:

const
  BUFSIZE = 1024 * 100;
var
  Stream: TMemoryStream;
  f: file of byte;
  FileName: string;
  buf: array[0..BUFSIZE] of byte;
  BytesRead: Integer;
begin
  Stream := TMemoryStream.Create();

  //Stream.Write(...);

  FileName := '...';

  AssignFile(f, FileName);

  FileMode := fmOpenRead;
  Reset(f);

  Stream.SetSize(FileSize(f) + Stream.Position);

  while not Eof(f) do
  begin
    BlockRead(f, buf, BUFSIZE, BytesRead);
    Stream.Write(buf, BytesRead);
  end;

  CloseFile(f);

Da die Streamgröße vorher gesetzt und dadurch aller Speicher in einem Rutsch alloziert wird, ist das ganze auch relativ schnell. :cyclops:

[alleinherrscher]

Der Ansatz ist echt lieb von dir gemeint :) Aber da ich nicht immer Dateien verschicke, sondern irgendwelche Daten ist das nicht allgemein genug. Ich hatte mir überlegt, evtl die Strings am Ende des Streams zu speichern. Da ich aber nicht weiß, wie lang die Daten sind, ist es nicht so einfach, hinterher die position der Strings zu ermitteln.

Das einzige was meiner Meinung nach gehen würde, ist eine Art Maker in den Stream zu setzen, also eine Bestimmte zeichenfolge, anhand derer man erkennen kann, wo die Strings anfangen...aber das ist auch nicht die feine englische Art, denn man stelle sich vor, dass (aus welchem grund auch immer) diese Zeichenfolge zufällig schon vorder in den daten vorkommt. Dann bricht die ganze Struktur zusammen :(


//EDIT:

MOMENT ich hab noch ne bessere Idee:

Kann ich den String hinterher nicht praktisch "von Hinten lesen"?

D.h. ich speichere zunächst den String und erst nach dem String die Länge des Strings im Stream.
Dann kann ich doch "von Hinten" erst die Länge des Strings auslesen (weil das ja n integer ist und immer gleich lang), dann die entsprechende Länge nach vorn wandern und den String auslesen usw... versteht ihr was ich meine?

Könnte das klappen?