Mapped Streams

[Neutral General]

Hi,

Also ich schreibe hier diesen Thread ganz neu. Der ein oder andere wird ihn wohl gar nicht mehr wiedererkennen. Naja Inhalt und überschrift haben sich auch ziemlich geändert/erweitert.

Ich hatte hier damals meinen TMMFStream vorgestellt. Heute will ich euch meine MappedStreams.pas vorstellen.

TCustomMappedStream
Das ist einfach nur die Basisklasse, von der alle anderen Streamklassen meiner neuen Unit abgeleitet sind. Der TCustomMappedStream ist von TStream abgeleitet.

TCustomMappedStream erweitert TStream um zwei neue Properties:

property Memory: Pointer read FMemory; Mit dieser Property lässt sich einfach durch einen Pointer auf die Daten des Streams zugreifen. Siehe Memory-Property vom TMemoryStream

property Readonly: Boolean read FReadOnly; Readonly ist eine Readonly property ( ) mit der man feststellen kann ob man nur Lese- oder auch Schreibzugriff auf die Streamdaten hat.
FReadonly wird im constructor der jeweiligen Streamklasse gesetzt und kann bei der Erstellung beeinflusst werden.

Diese Klasse bitte nie erstellen!

TFileStreamEx
TFileStreamEx ist im Prinzip ein TFileStream mit Memory-Property, der MMF benutzt.

constructor Create(const Filename: String; Mode: Word); Wie man sieht, wird TFileStreamEx genauso benutzt wie ein normaler TFileStream.
Neues Feature: fmCreateTemporary kann als Mode-Parameter übergeben werden. Die erstellte Datei wird dann beim freigeben des FileStreams gelöscht.

TIPCStream
Dieser Stream vereinfacht die IPC durch die Benutzung von MMFs.

constructor Create(Name: String; ReadonlyAccess: Boolean = false; FileSize: Int64 = -1); Name: Der Name der MMF, die erstellt werden soll bzw. zu der man connecten will.
ReadonlyAccess: Bei true, ist das schreiben in die MMF nicht möglich, und endet in einer Exception.
FileSize: Gibt die größe der MMF an. Es ist hier nur ein vielfaches von 4096 (4KB) erlaubt. Ansonsten wird automatisch aufgerundet. (50 --> 4096, 5000 --> 8192, etc). Wird -1, bzw eine Zahl < 0 angegeben bedeutet das, dass man keine MMF erstellen will, sondern zu der im Name-Parameter angegebenen, bereits erstellten MMF connecten will.

TVirtualStream
Mir ist leider kein besserer Name eingefallen. Ich glaube der hier triffts nicht so ganz. Bin für Namensänderungen aber offen.

Dieser Stream ist in gewisser Weise etwas ganz besonderes
Er kann z.B. die Funktion eines "Stream im Stream" erfüllen. Ich erkläre den constructor, danach wird es eventuell klarer sein:

constructor Create(P: Pointer; DataSize: Int64; ReadonlyAccess: Boolean = true); P: Pointer zu irgendwelchen Daten.
DataSize: Größe der Daten
ReadonlyAccess: Siehe TIPCStream

Diesen Stream kann man wie gesagt auf mehrere Arten verwenden. Stellen wir uns vor, wir hätte eine Datei in einen TFileStreamEx geladen:

Code:

------------------------------------------------------------
                          DATA
------------------------------------------------------------

Diese Datei ist jetzt vielleicht ein Archiv o.ä. in dem mehrere Dateien gespeichert sind:

Code:

------------------------------------------------------------
  Bild1.jpg   |  Alles aus Liebe.mp3 | MappedStreams.pas
------------------------------------------------------------

Nun könnte man einen VirtualStream erstellen:

TVirtualStream.Create(Pointer(Cardinal(FileStreamEx.Memory)+Offset('Alles aus Liebe.mp3')),SizeOf('Alles aus Liebe.mp3')); und nun würde das ganze so aussehn:

Code:

<------------------- FileStreamEx-------------------------->
------------------------------------------------------------
  Bild1.jpg   |  Alles aus Liebe.mp3 | MappedStreams.pas
------------------------------------------------------------
              <---- VirtualStream --->

Dabei wird beim lesen und schreiben direkt aus den FileStreamEx Daten gelesen und auch in diese hineingeschrieben. Es ist also eine Art Metastream.

Man könnte das natürlich auch lösen indem man einen TMemoryStream benutzt und die Daten per CopyFrom kopiert, aber damit würde man zusätzlichen Speicher belegen und es wäre eben nur eine Kopie!

Eine andere Anwendungsmöglichkeit wäre z.B. soetwas:

Delphi-Quellcode:

procedure Blubb;
var P: Pointer;
    vs: TVirtualStream;
begin
  GetMem(P,200);
  vs := TVirtualStream.Create(p,200,false);
  try
    vs.Write(...);
  finally
    vs.Free;
    FreeMem(P);
  end;
end;

Ein Beispiel für den TFileStreamEx erspare ich mir, weil er ja eigentlich genauso wie ein TFileStream benutzt wird, bis auf die Möglichkeit temporäre Dateien erstellen zu können und das man einen TFileStreamEx mit einem TVirtualStream verbinden kann

Dann der TIPCStream:

Server

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
  IPC := TIPCStream.Create('test',false,4096);  // muss natürlich wieder freigegeben werden!
end;

procedure TForm1.Button2Click(Sender: TObject);
var l: Integer;
begin
  l := Length(Edit1.Text);
  IPC.Write(l,SizeOf(Integer));
  IPC.Write(Edit1.Text[1],l);
end;

Client

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
  IPC := TIPCStream.Create('test',false); // muss natürlich wieder freigegeben werden!
end;

procedure TForm1.Button2Click(Sender: TObject);
var l: Integer;
    s: String;
begin
  IPC.Read(l,SizeOf(Integer));
  SetLength(s,l);
  IPC.Read(s[1],l);
  ShowMessage(s);
end;

So das wars dann soweit. Würde mich freuen wenn sich das jemand mal anschaut

[Neutral General]

Oh. Gar nicht gut.

Danke, dann muss ich das noch ändern. Hab ja überhaupt keine Bereichsprüfung

[himitsu]

Zitat von Neutral General:

Hab ja überhaupt keine Bereichsprüfung

Ein bissl was ist schon drin.

"Write" schreibt und "Read" liest zumindestens nicht hinter den Speicher, aber dafür kann man halt davor.