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

[himitsu]

logisch wäre es andersrum richtig (FMemory ist ja von FMapHandle abhängig)

Delphi-Quellcode:

procedure TMMFStream.CloseMMF;
begin
  UnMapViewOfFile(FMemory);
  CloseHandle(FMapHandle);
end;

und FFileHandle nach CreateFile müßte noch geprüft werden,
falls die Datei nicht geöffnet werden kann (z.B. falscher Dateiname oder ungenügend Rechte)

[add]
für IPC wäre es noch schön, wenn man den MappingName (CreateFileMapping-lpName) getrennt angeben kann.

[Neutral General]

Zitat von himitsu:

logisch wäre es andersrum richtig (FMemory ist ja von FMapHandle abhängig)

Delphi-Quellcode:

procedure TMMFStream.CloseMMF;
begin
  UnMapViewOfFile(FMemory);
  CloseHandle(FMapHandle);
end;

und FFileHandle nach CreateFile müßte noch geprüft werden,
falls die Datei nicht geöffnet werden kann (z.B. falscher Dateiname oder ungenügend Rechte)

Sicher, das es andersrum muss? Ich meine es sieht ja so aus:

Code:

  - FMapHandle
     - FMemory

oder nicht? ...

Ja ich hatte das FileHandle früher geprüft, aber was soll ich groß tun bei einem ungültigen Handle?

[himitsu]

Zitat:

aber was soll ich groß tun bei einem ungültigen Handle?

z.B. 'ne Exception werfen oder FPaging auf True setzen

Zitat:

sicher, das es andersrum muss? Ich meine es sieht ja so aus:

du machst doch zuerst CreateFileMapping und dann MapViewOfFile, also freigeben in umgekehrter Reinfolge.

PS: hatte oben noch was zuediert

[Neutral General]

Zitat von himitsu:

Zitat:

aber was soll ich groß tun bei einem ungültigen Handle?

z.B. 'ne Exception werfen oder FPaging auf True setzen

Zitat:

sicher, das es andersrum muss? Ich meine es sieht ja so aus:

du machst doch zuerst CreateFileMapping und dann MapViewOfFile, also freigeben in umgekehrter Reinfolge.

PS: hatte oben noch was zuediert

Ok ich schmeiß ne Exception

Stimmt, du hast Recht, ich muss die Handles in der anderen Reihenfolge freigeben..

Zu deinem Edit:

Ja ich dachte, das löse ich beides mit dem "Name"-Parameter.. Wollte keinen ellenlangen constructor mit x-Parametern haben..

[himitsu]

dann kannst du den Namen (CreateFileMapping) eigentlich auch weglassen, da man ja über die Datei an die MMF rankommt.


PS: nur CreateFileMapping.Name und keine Datei ergibt eine MMF nur im RAM ... hervorragend für IPC.

[Neutral General]

Zitat von himitsu:

dann kannst du den Namen (CreateFileMapping) eigentlich auch weglassen, da man ja über die Datei an die MMF rankommt.


PS: nur CreateFileMapping.Name und keine Datei ergibt eine MMF nur im RAM ... hervorragend für IPC.

Ja ich übergebe den Namen ja nicht wenn eine Datei erstellt wird

Delphi-Quellcode:

// ...
else if (not FPaging) then
    FMapHandle := CreateFileMapping(FFileHandle,nil,PAGE_READWRITE,0,MMFSize,nil) //<-- nil

Außerdem verstehe ich deine Antwort leider nicht so wirklich, sorry.

[himitsu]

ups ja, ganz übersehn

man kann ja ohne Datei arbeiten

Delphi-Quellcode:

if not FPaging then
else
  FFileHandle := INVALID_HANDLE_VALUE;

[Neutral General]

Hi,

Neue Version ist online. Siehe erster Post. Es hat sich einiges geändert!

[himitsu]

Delphi-Quellcode:

Stream.Seek(-20, soBeginning);
Stream.Write(Buffer, 20);

Delphi-Quellcode:

Stream.Seek(-2000000000, soCurrent);
Stream.Write(Buffer, 20);

Ich fürchte in deinen virtuellen Stream bekommt man leicht ein Speicherleck rein.
(hab's nicht getestet, aber es sieht so aus)