Hallo zusammen,
für den Titel ist mir leider nicht allzu sinnvolles eingefallen. Worum gehts? Ich habe ein Stück Code, da wird mit Datenträger (z.B. CD-ROM) und Dateien gearbeitet. Da gibt es FindFirst, FindNext, GetDiskClass und weitere übliche functions und procedures für Dateien. Also alles nicht besonderes ungewöhnliches.
Nun möchte ich den Code nicht für Dateien auf CD-ROM oder Festplatte, sondern für Dateien in einer ISO- oder ZIP-Datei benutzen - und das ohne diese erst temporär wo hinzukopieren.

Vorstellen könnte ich mir einen Wrapper zu machen der alle diese Methoden ersetzt. In einem anderen Projekt habe ich so was schon gemacht, da ging es aber um die Testbarkeit mit Mocks. Ist es klar oder soll ich ein Beispiel erstellen?
Die eigentlichen Fragen: a) Gibt es schon sowas irgendwo? b) Gibt es bessere Ideen?

(Wie man auf Dateien einer ISO-Datei zugreift, da rum geht es hier: https://www.delphipraxis.net/216120-...-auslesen.html)

Beispiel erstellen oder Interfaces nehmen.

Hier nun ein Beispiel. Es ist nur für eine Funktion. Eine Klasse für ZIP-Dateien wäre anlog zu der für ISO.

zusammenfalten · markieren

Delphi-Quellcode:

unit FileWrapper;

interface

uses
  System.SysUtils;

type
  IFileWrapper = interface
    ['{18943149-C314-4003-BC7F-F50C3860804A}']
    function FileExists(const AFilename: string): Boolean;
  end;

  //Für ein standardmässiges Dateisystem
  TDefaultFileWrapper = class(TInterfacedObject, IFileWrapper)
  public
    function FileExists(const AFilename: string): Boolean;
  end;

  //Für eine ISO-Datei
  TIso8660FileWrapper = class(TInterfacedObject, IFileWrapper)
  public
    constructor Create(const AIsoFilenname: string);
    //True wenn Datei in der ISO-Datei existiert. Laufwerksbuchstabe wird ignoriert
    function FileExists(const AFilename: string): Boolean;
  end;

var
  //Ein FileWrapper für die üblichen Fälle
  DefaultFileWrapper: IFileWrapper;

implementation

function TDefaultFileWrapper.FileExists(const AFilename: string): Boolean;
begin
  Result := System.SysUtils.FileExists(AFilename);
end;

constructor TIso8660FileWrapper.Create(const AIsoFilenname: string);
begin
  inherited Create();
  //TODO : ISOLib einbinden
end;

function TIso8660FileWrapper.FileExists(const AFilename: string): Boolean;
begin
  Result := False; //TODO : implement FileExists
end;

//------------------------------------------------------------------------------
//Das ist nun ein extrem rudimentäres Beispiel für den alten Code
procedure AltVerarbeiteCD(ALaufwerksbuchstabe: Char);
begin
  if FileExists(ALaufwerksbuchstabe + '\setup.ini') then begin
    //Werte Dateien aus - sehr viele Dateioperationen
  end;
end;

//------------------------------------------------------------------------------
//Das wären die neue Methoden die den Wrapper benutzt.
//Alle Fileoperationen werden vorne mit "AFileWrapper." ergänzt
procedure NeuVerarbeite(
  AFileWrapper : IFileWrapper;
  ALaufwerksbuchstabe: Char);
begin
  if AFileWrapper.FileExists(ALaufwerksbuchstabe + '\setup.ini') then begin
    //Werte Dateien aus - sehr viele Dateioperationen
  end;
end;

procedure NeuVerarbeiteCD(ALaufwerksbuchstabe: Char);
begin
  NeuVerarbeite(DefaultFileWrapper, ALaufwerksbuchstabe);
end;

procedure NeuVerarbeiteIso(AIsoFilenname: string);
var
  Iso8660FileWrapper: IFileWrapper;
begin
  Iso8660FileWrapper := TIso8660FileWrapper.Create(AIsoFilenname);
  NeuVerarbeite(Iso8660FileWrapper, '-');
end;

initialization

DefaultFileWrapper := TDefaultFileWrapper.Create();

end.

Nochmals die Fragen: a) Gibt es schon sowas irgendwo? b) Gibt es bessere Ideen?

To my knowledge there is only one library did that full virtualization, and it is/was magnificent, it was called something (i don't recall to be honest) but it it was almost always a companied by another library called CallBack from Eldos, well there is no Eldos now, but CallBack is still there

https://www.callback.com/

The prices weren't cheap back in days, but now it seems way more expensive and more like nsoftware licensing system.


ps: I vaguely remember something like CallBack File Storage or something, the naming on the site reminding me.

ZIP-Datei ist extrem einfach. Falls die Klassen aus Delphi nicht reichen, kann man das auch einfach in max. 20 Zeilen selbst schreiben. Hab ich letztens gemacht, da meine ZIP-Dateien einen obfuszierten Header haben konnten.

Um dann doch noch was Konstruktives beizutragen, hier der Code für eine eigene ZIP-Durchiteration:
- Beispielcode für ZIP Local Header (Wenn die Magische Zahl $03575157 ist, dann ist es die Datei eine obfuszierte Datei, für die dieses Tool ist. Diesen Code kannst du dir schenken. Neben dem Local Header gibt es noch zwei andere Arten von ZIP-Headern, die auch verpflichtend in jede ZIP-Datei aufzunehmen sind. Sie sind aber komplett nutzlos, weshalb sie zum Beispiel von 7-Zip ignoriert werden, egal ob sie fehlen, ungültig oder widersprüchlich sind. Ich habe herausgefunden, dass es Windows nicht egal ist, und du es durch Widersprüche in ZIP-Headern dazu bringen kannst, in Dauerschleife sinnlose Fehlermeldungen anzuzeigen, ohne dass der Benutzer erkennen kann, wo die herkommen.)
- Beispielcode für dessen Verwendung (Wichtig sind die ersten zwei Zeilen und vor allem die letzte Zeile.)
Kann man noch ein bisschen was einbauen, damit man bei einer ungültigen Datei nicht übers Ende hinaus liest.

Dnake für alle Rückmeldungen.

@Kas Ob.: Ja, das ist preislich schon eine andere Liga ... Davon abgesehen habe ich es nicht ganz so verstanden was die anbieten. Es macht für mich den Eindruck als da tatsächlich ein virtuelles Dateisystem in Windows zum Einsatz kommt. Ich möchte dagegen nur die Delphi-Datei-Methoden virtuell haben.

@Redeemer: ich vermute mal, dass Du mich nicht richtig verstanden hast. In deinem Code finde ich nirgendwo ein FileExists.
Eine function TZipFileWrapper.FileExists(const AFilename: string): Boolean; zu machen scheint mir nicht gerade schwer zu sein. Mir geht es hier in dem Thread nicht darum wie man auf konkret Dateien, Iso oder Zip zugreift sondern wie man diese drei unter einen Hut bekommt, so dass man Dateioperationen in existierendem Code allenfalls marginal ändern muss.

Zitat von freimatz:

@Kas Ob.: Ja, das ist preislich schon eine andere Liga ... Davon abgesehen habe ich es nicht ganz so verstanden was die anbieten. Es macht für mich den Eindruck als da tatsächlich ein virtuelles Dateisystem in Windows zum Einsatz kommt. Ich möchte dagegen nur die Delphi-Datei-Methoden virtuell haben.

Hi,

Well, most likely i don't understand your need 100%, though i got the idea that you looking for some sort of solid file storage, or at least the interface or layer for such thing solution, back when it was Eldos, these 4 libraries were more than 4 and smaller, and per their designs they fit together also they had brilliant layered design so at every stage you can derive your own work and replace the default, anyways, if you are looking for the virtual or the solid file storage, then :

1) if you look at https://www.callback.com/cbfsvault then you will see that you can build and use the virtual/solidfile , they called it CBFS Vault layer, yet again this file(/system) could be mounted on every system as the library comes with many OS drivers to do so, or leave it for your own applications (example, called users in the diagram), again it is multi layered library,
to make it clearer with example, if you are familiar with TrueCrypt/VeraCrypt then you can have your own natively Pascal/Delphi built with few lines of code, and again this doesn't mean you are limited to their solid file storage standard as you can provide the files as you see fit from zip or generate them on the fly, these are just a scratch of what this library can do, and i hope it did clear some.

2) I remember seeing and testing few libraries in torry.net years ago, well can't find much now, but have a look at https://github.com/gabr42/GpDelphiUn...redStorage.pas it could be your needed interface, yet i already have fixed data structure to be used with its own, so it is solid file storage only for storing ordinary files (not virtualized), but non the less it is great and will provide you with idea(s).

Zitat von freimatz:

@Redeemer: ich vermute mal, dass Du mich nicht richtig verstanden hast. In deinem Code finde ich nirgendwo ein FileExists.

Nein, weil ich gedacht habe, eine einzige Zeile hinzuzufügen, wäre drin. Diese Zeile lautet:
Dictionary.Add(LocalHeader.FileName, Stream.Position);
Deine gewünschte Funktion ist dann TDictionary<string, Int64>.ContainsKey.

Hallo Janni,
entweder verstehe ich Dich nicht oder Du mich

Wo sollte diese Zeile "Dictionary.Add(LocalHeader.FileName, Stream.Position);" hin?
Und wo bekomme ich Dictionary, LocalHeader und Stream her?

Und das "TDictionary<string, Int64>.ContainsKey" - ersetzt das dann ein FileExists?
Und wie wird gesteuert ob das auf der CD, einem ISO-Image oder in einer ZIP arbeiten soll?

Und wie sieht aus mit "FindFirst, FindNext, GetDiskClass und weiteren üblichen functions und procedures für Dateien" aus?

Zitat von Kas Ob.:

Well, most likely i don't understand your need 100%, though i got the idea that you looking for some sort of solid file storage, or at least the interface or layer for such thing solution, ...

Nein, ich suche kein Dateisystem. Ich habe bereits drei: a) das Windowsdateisystem (NTFS oder was auch immer) b) ZIP-Archive und c) ISO-Images
Ja, ich suche einen Layer oder sowas damit ich den Code, der für a) existiert, auch für c) und ggf. b) verwenden kann. Und mit möglichst wenigen Änderungen an diesem Code - denn das ist fehleranfällig.