Guid erzeugen

[Delbor]

Hi zusammen

Folgende Funktion soll mir eine GUID erzeugen, ein File anlegen, da die Guid speichern und diese dann als Bytearray zurüchgeben:

Delphi-Quellcode:

function TOpenFileFrame.CreateIDFile(LPath : String): TByteArray;
  var IdFile : TFileStream; ID_GUID: TGUID; IdStr: String;
      UniqueName: TEndian; Len: Longint;
begin
  if CreateGUID(ID_GUID) <> 0 then
     ShowMessage('Creating GUID failed!')
  else
  begin
    Showmessage('Size of UniqueName := ' + IntToStr(SizeOf(UniqueName)));
    IdFile := TFileStream.Create(LPath,fmCreate);
    try
     Len := Length(GUIDToString(ID_GUID));
     IdFile.Write(Len, SizeOf(Len));
     IdStr := GUIDToString(ID_GUID);
     IdFile.Write(IdStr, Len);
    finally
      IdFile.Free;
    end;
    Result := ID_Guid.ToByteArray(ID_GUID);
  end;
end;

Aufgrufen wird diese Funktion, wenn die Pfade vorhandener Bilddateien eingelesen werden:

Delphi-Quellcode:

    if not FileExists(LPath+'IdentFile.cgf') then
    begin    // ist in dem Ordner kein IdentifikationsFile
      ByteID := CreateIDFile(LPath);
    end;

Einen Compilierungsversuch quittiert Delphi wie folgt:

Zitat:

[dcc32 Fehler] FileOpenFrameUnit.pas(196): E2010 Inkompatible Typen: 'TEndian' und 'TGUID'

Der Rückgabewert soll in einer DB gespeichert werden.
Was mache ich falsch?

Gruss
Delbor

[bra]

Delphi-Quellcode:

UniqueName: TEndian;

wird im Code außer bei der Showmessage nirgendwo verwendet. Wozu ist das da?

[Delbor]

Hi bra

Zitat:

UniqueName: TEndian; wird im Code außer bei der Showmessage nirgendwo verwendet. Wozu ist das da?

Das war einer meiner Versuche - gelöscht hab ichs noch nicht, weil ich noch nicht weiss, ob das wirklich falsch war. Anrerseits - als Rückgabewert ist das sicher falsch, da letzterer Biär in die DB geschrieben werden soll.

Gruss
Delbor

[Sir Rufo]

Warum machst du dir das Leben so schwer?

Erstelle dir eine Klasse, die einen Stellvertreter für so ein Archiv-Verzeichnis darstellt.

Der gibst du alle nötigen Methoden/Eigenschaften mit, die du dort brauchst. Eine Eigenschaft wäre z.B. die GUID und eine Methode wäre z.B. Init.

Ist Verzeichnis noch nicht initialisiert, dann liefert die GUID-Eigenschaft ein

Delphi-Quellcode:

TGUID.Empty

zurück.

Das würde den Umgang mit diesen Verzeichnissen auf jeden Fall erleichtern.

[Delbor]

Hi Sir Rufo

Da hast du sicher recht - zukünftig das Zeugs nur noch auslesen anstat die ganze Sache neu zu schreiben, macht wirklich Sinn. Nur habe ichh eben mit dem Umgang der Datentypen noch Probleme. Bei meiner obigen Zuweisung an Result sind alle beteilligtten Bezeichner vom Typ TGuid, mit Ausnahme von ToByteArray - die ist vom Typ TEndian.
Aber ich seh grad in der Help:

Zitat:

function ToByteArray(DataEndian: TEndian = TEndian.Little): TBytes;

Nachdem ich die Deklatrationen nun angepasst habe:

Zitat:

[dcc32 Fehler] FileOpenFrameUnit.pas(196): E2010 Inkompatible Typen: 'TEndian' und 'TGUID'

Die selbe Fehlermeldung wie gehabt, nur dass der "fremde" Datentyp jetzt TGuid und nicht mehr TEndian ist.
Da TEndian lediglich ein Aufzählungstyp mit 2 Werten ist, wars vorher wohl richtiger.

Deinen Vorschlag einer Klasse hab ich mal begonnen, umzusetzen:

Zitat:

type
TIdentifierClass = Class(TPersistent)
private
FGuid: TGuid;
FByteArray : TByteArray;
FUniqquename: String;
FPath: String;
FFileStream: TFileStream;
FFileName : String;
function GetGuid: Boolean;
procedure SetBinaryGuid(Value: TGuid);
function GetBinaryGuid: TGuid;
public
procedure SaveToFile(Value: String);
property Guid: Boolean read GetGuid;
property BinaryGuid: TGuid read GetBinaryGuid write SetBinaryGuid;
property StringGuid: TGuid read GetStringGuide write SetStringGuide;
property FileName: String read FFileName write FFilename;
end;

Aber die eigentliche Schwierigkeit schien mir: solange ich den richtigen Umgang in meiner Funktion nicht schaffe, krieg ich auch keine anständige Klasse hin.
Aber manchmal scheint Wahnwitz testen zum Erfolg zu führen =>> Parameter TGuid durch Little ersetzt, und schon hat mir Delphi meinen Code ... nicht um die Ohren gehauen....

Gruss
Delbor

[Sir Rufo]

Du kannst ja mal das hier ausprobieren

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.IOUtils,
  System.SysUtils;

type
  TArchiveFolder = class
  private
    FID       : TGUID;
    FFullName : string;
    FFirstLoad: Boolean;
    function GetID: TGUID;
    function GetName: string;
    function GetIdFileName: string;
    function GetIsInitialized: Boolean;
    procedure EnsureFirstLoad;
  public
    property FullName     : string read FFullName;
    property ID           : TGUID read GetID;
    property IsInitialized: Boolean read GetIsInitialized;
    property name         : string read GetName;
  public
    constructor Create( const Name: string );
  public
    procedure Init( CreateIfNotExists: Boolean = False );
    procedure Reload;
  end;

  { TArchiveFolder }

constructor TArchiveFolder.Create( const Name: string );
begin
  if TFile.Exists( name )
  then
    raise Exception.Create( 'Fehlermeldung' );

  inherited Create;
  FFullName := TPath.GetFullPath( name );
end;

procedure TArchiveFolder.EnsureFirstLoad;
begin
  if not FFirstLoad
  then
    begin
      Reload;
      FFirstLoad := True;
    end;
end;

function TArchiveFolder.GetID: TGUID;
begin
  EnsureFirstLoad;
  Result := FID;
end;

function TArchiveFolder.GetIdFileName: string;
begin
  Result := TPath.Combine( FFullName, '.folderid' );
end;

function TArchiveFolder.GetIsInitialized: Boolean;
begin
  EnsureFirstLoad;
  Result := FID <> TGUID.Empty;
end;

function TArchiveFolder.GetName: string;
begin
  Result := TPath.GetFileName( FFullName );
end;

procedure TArchiveFolder.Init( CreateIfNotExists: Boolean = False );
begin
  Reload;

  if IsInitialized
  then
    raise Exception.Create( 'Fehlermeldung' );

  if not TDirectory.Exists( FFullName )
  then
    begin
      if CreateIfNotExists
      then
        TDirectory.CreateDirectory( FFullName )
      else
        raise Exception.Create( 'Fehlermeldung' );
    end;

  TFile.WriteAllText( GetIdFileName( ), TGUID.NewGuid.ToString );

  Reload;
end;

procedure TArchiveFolder.Reload;
var
  lIdFileName: string;
begin
  lIdFileName := GetIdFileName( );
  if not TFile.Exists( lIdFileName )
  then
    FID := TGUID.Empty
  else
    FID := TGUID.Create( TFile.ReadAllText( lIdFileName ) );
end;

procedure Main;
var
  fld: TArchiveFolder;
begin
  fld := TArchiveFolder.Create( '.' );
  try
    if not fld.IsInitialized
    then
      begin
        WriteLn( 'Init ',fld.FullName );
        fld.Init( );
      end;

    WriteLn( fld.ID.ToString( ) );
  finally
    fld.Free;
  end;

  fld := TArchiveFolder.Create( '.' );
  try
    if not fld.IsInitialized
    then
      begin
        WriteLn( 'Init ',fld.FullName );
        fld.Init( );
      end;

    WriteLn( fld.ID.ToString( ) );
  finally
    fld.Free;
  end;

end;

begin
  try
    Main( );
  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;

  ReadLn;

end.

[mm1256]

Zitat:

Zitat von Delbor (Beitrag 1332897)

...Aufgrufen wird diese Funktion, wenn die Pfade vorhandener Bilddateien eingelesen werden...

Hmmmm...Diese Vorgehensweise funktioniert dann wohl auch nur auf Laufwerken bzw. deren Verzeichnissen, auf die du Vollzugriff hast, also Dateien anlegen darfst. Möchte mich da nicht einmischen, aber ist das wirklich eine gute Lösung?

[Delbor]

Hi zusammen

Erstmal muss ich eine Frage stellen, für die ich nach längerem suchen keine Antwort finde. Wieso funktioniert das problemlos wird hier der Parameter 'Little' richtig erkannt:

Delphi-Quellcode:

function TOpenFileFrame.CreateIDFile(LPath : String): TBytes;
  var IdFile : TFileStream; ID_GUID: TGUID; IdStr: String;
      UniqueName: TEndian; Len: Longint;
begin
  if CreateGUID(ID_GUID) <> 0 then
     ShowMessage('Creating GUID failed!')
  else
  begin
    IdFile := TFileStream.Create(LPath,fmCreate);
    try
     Len := Length(GUIDToString(ID_GUID));
     IdFile.Write(Len, SizeOf(Len));
     IdStr := GUIDToString(ID_GUID);
     IdFile.Write(IdStr, Len);
    finally
      IdFile.Free;
    end;
    Result := ID_Guid.ToByteArray(Little);
  end;
end;

während das hier nicht tut:

Delphi-Quellcode:

function TIdentifierClass.GetBinaryGuid: TGuid;
begin
  FGuid := FGuid.NewGuid;
  Result := FGuid.ToByteArray(Little);  //  SysUtils ist in uses enthalten
end;

Korpus Delicti ist der Parameter Little => unbekannter Bezeichner.
FGuid ist ein Feld vom Typ TGuid.

@Sir Rufo: Sehe ich das richtig: du erzeugst ein Konsolenprogramm, das im zu idsentifizierenden Ordner zu liegen kommt, den GUID erzeugt und den aktuellen Pfad zurückgibt?

Gruss
Delbor

[Delbor]

Hi mm1256

Zitat:

Hmmmm...Diese Vorgehensweise funktioniert dann wohl auch nur auf Laufwerken bzw. deren Verzeichnissen, auf die du Vollzugriff hast, also Dateien anlegen darfst. Möchte mich da nicht einmischen, aber ist das wirklich eine gute Lösung?

Welche andere Lösung gäbe es denn sonst noch?
Die Bilder sind für (m)eine Website bestimmt. Wegen der Grösse der Bilder sollen die nicht in die DB geschrieben werden - jedenfalls nicht in die hier zur Debatte stehende Server-Datenbank. Die Bildgrösse bewegt sich von ca. 10MB bei mir auf aktuell 24MB (10- bzw. 24 Megapixel je nach Kameramodell).
Hintergrund ist eigentlich: die Bilder liegen auf einer externen Festplatte, und deren Laufwerksbuchstabe kann sich unter Windows ändern.
Das aber heisst ja: Wenn ich den Pfad zu so einem Bild in der DB abspeichere, muss er nicht in jedem Fall auch später noch stimmen. Ist in dem Ordner/auf dem Laufwerk/der Partition ein IDFile, lässt sich so ein Ordner auch dann noch identifizieren, wenn sich sein Speicherort geändert hat.

Gruss
Delbor

[Sir Rufo]

Zitat:

Zitat von Delbor (Beitrag 1333144)

@Sir Rufo: Sehe ich das richtig: du erzeugst ein Konsolenprogramm, das im zu idsentifizierenden Ordner zu liegen kommt, den GUID erzeugt und den aktuellen Pfad zurückgibt?

Nein, ich erzeuge eine Instanz einer Klasse und gebe der Klasse den Pfad mit. Dann kann ich abfragen, ob dieser Ordner schon initialisiert ist und entweder initialisieren und die ID abfragen oder eben direkt abfragen, wenn schon (irgendwann mal) initialisiert wurde.

Wo die Anwendung liegt ist also egal.