TFileStream - irgendwie raff ichs net

[Predator]

moin Jungs,

also ich versuche per TFileStream eine Datei einzulesen und wieder zu speichern (ich will später dann noch eine Verschlüsselungsroutine dazusetzten, das kommt dann aber in einen eigenen Thread). Jetzt mach ich das so:

Delphi-Quellcode:

function Kopiere(Input,Output: string) : string;
var
    fs,dest : TFileStream;
    Buffer : Byte;
begin
    fs := TFileStream.Create(Input, fmReadOnly);
    fs.Read(Buffer, fs.size);
try
    dest := TFileStream.Create(Output, fmCreate);
    dest.Write(Buffer, sizeof(Buffer));
finally
    FreeAndNil(fs);
    FreeAndNil(dest);
end;
end;

so nur irgendwie kommt manchmal ne Zugriffsverletzung bei Adresse irgendwas oder die Datei wird erstellt nur nichts kopert (0 KB);

Was hab ich da falsch gemacht ? Ich sitze jetzt schon seit gestern Abend daran das gibts doch net.

Hat jemand ein Tut wo alles über Streams(Memory,File,u.s.w.) steht ?

Danke !!!!

cu
Predator

[mirage228]

Delphi-Quellcode:

var
  InPutS, OutPutS: TFileStream;
  Mode: Word;
begin
  InPutS := TFileStream.Create(InPut, fmOpenRead or fmShareDenyNone);

  if not FileExists(OutPut) then Mode := fmCreate else Mode := fmOpenWrite;
  OutPutS := TFileStream.Create(OutPut, Mode or fmShareDenyNone);

  try
    OutPutS.Position := 0;
    OutPutS.CopyFrom(InPutS, 0); // Kopiert InPut Datei nach OutPut;
    // restliche verarbeitung von OutPutS
  finally
    OutPutS.Free;
    InPutS.Free;
  end;
end;

so solltes gehn.

mfG
mirage228

[Luckie]

Das reine Kopieren auf eine Schlag nützt ihm nichts, wenn er noch was dazwischen hängen will.

Delphi-Quellcode:

            GetMem(Buffer, 1024);
            try
              // as long as we have not reached the end of the source stream
              while (SrcStream.Position < SrcStream.Size) do
              begin
                // how much to read
                if SrcStream.Size - SrcStream.Position > BlockSize then
                  Len := BlockSize
                else
                  Len := SrcStream.Size - SrcStream.Position;
                // read into the buffer
                SrcStream.ReadBuffer(Buffer^, Len);
                // encode the buffer
                EncodeBuffer(Buffer^, Buffer^, len);
                // write the buffer
                DestStream.WriteBuffer(Buffer^, Len);
              end;
            finally
              // clean up the buffer
              FreeMem(Buffer);
            end;

Buffer ist als Pointer deklariert. BlockSize ist eien Konstante, die angibt wie vile jewals gelesen werden soll. Ich habe sie mit 1024 initialisiert.
Das EncodeBuffer ist aus Hagen Reddmanns DEC, dürfte dich erstmal nicht interessieren.

[Predator]

@Luckie

was ist jetzt wenn ich nicht nur 1024 KB einlesen will sondern die ganze Datei ?
z.b: ein 10 MB großes File ?

Und wie man ja so schön sagt : Aus Fragen lernt man

also:

Delphi-Quellcode:

try
              // as long as we have not reached the end of the source stream
              while (SrcStream.Position < SrcStream.Size) do
              begin
                // how much to read
                if SrcStream.Size - SrcStream.Position > BlockSize then
                  Len := BlockSize
                else
                  Len := SrcStream.Size - SrcStream.Position;
                // read into the buffer

Was wird da genau gemacht ?

Delphi-Quellcode:

SrcStream.ReadBuffer(Buffer^, Len);

Was ist der unterschied zwischen readBuffer und Read bzw. WriteBuffer und Write ?


Danke im Voraus.

[mirage228]

Moin Predator,

Antwort auf Frage 1:
das ganze ist eine Schleife, die solange 1024er Blöcke verschlüsselt, bis nix mehr von der datei das ist (wenn weniger als 1024 übrig sind, dann nimmt der den Rest)

[Luckie]

Ich dachte der Code ist mit den Kommentaren selbst erklärend. Aber gut.
Als erstes reservieren wir 1024 Byte Speicher.
Dann kommt die Schleife, die so lange läuft, bis der Dateizeiger am Ende der Quelldatei angekommen ist.
In der Schleife werden 1024 Blöcke gelesen, verschlüssel und wieder geschrieben. Da es nun sein kann, dass die Quelldateigröße kein Vielfaches von 1024 ist, ziehen wir von der Größe der Quelldatei die aktuelle Position ab und kucken so, ob noch 1024 Byte gelesen werden können. Ist dies der Fall werden 1024 Byte gelesen, wenn nicht nur noch so viel, wie übrig ist.

[Predator]

@Luckie

ich hab den Code jetzt mal in meinen angepasst. Müsste so richtig sien oder ?

Delphi-Quellcode:

function Kopiere(Input, Output: string) : string;
const
BlockSize = 1024;
var
fs: TFileStream;
Buffer: Pointer;
Len: Integer;
dest: TFileStream;
begin
fs := TFileStream.Create(Input, fmOpenRead);
dest := TFileStream.Create(Output, fmCreate);
GetMem(Buffer, 1024);
try
while (fs.Position < fs.Size) do
begin
if fs.Size - fs.Position > BlockSize then
Len := BlockSize
else
Len := fs.Size - fs.Position;

fs.ReadBuffer(Buffer^, Len);
dest.WriteBuffer(Buffer^, Len);
end;
finally
FreeMem(Buffer);
end;
end;

hab jetzt mal schnell copy,paste ohne Formatierung kopiert.

Trotzdem ist das File 0 KB.

[Predator]

sorry hat sich schon erledigt.

der hatte mein Testfile überschrieben beim Fehler deswegen war output auch 0 KB bin ich blöd :wall: :wall:

Gibt es irgendwo ein Tutorial bzw. Referenzen zum DEC vom Herrn Reddmann ?

[Luckie]

In dem Thread: http://www.delphipraxis.net/internal...erschl%FCsseln gibt es gegen Ende Beispiel Code von mir und Daniel.

[Predator]

ok danke nochwas:

wie kann ich jetzt z.B. am Anfang und ende das noch einfügen ?

[START CODE]
[END CODE]

???

Habs mit dest.Write versucht aber dann ist der rest nicht komplett.

Danke im voraus. :)