AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Programmierung allgemein Programmieren allgemein TGUID - einzigartige ID auf andere Computer Systeme ?
Thema durchsuchen
Ansicht
Themen-Optionen

TGUID - einzigartige ID auf andere Computer Systeme ?

Ein Thema von paule32.jk · begonnen am 20. Okt 2023 · letzter Beitrag vom 2. Nov 2023
Antwort Antwort
Seite 2 von 7     12 34     Letzte »    
Benutzerbild von paule32.jk
paule32.jk

Registriert seit: 24. Sep 2022
Ort: Planet Erde
356 Beiträge
 
Delphi 11 Alexandria
 
#11

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 20. Okt 2023, 16:50
wir hatten doch mal so ein kleines Thema mit der Reg.DB bei Mathias...
Frag doch einfach
Alles was nicht programmiert werden kann, wird gelötet
  Mit Zitat antworten Zitat
Benutzerbild von jaenicke
jaenicke
Online

Registriert seit: 10. Jun 2003
Ort: Berlin
9.572 Beiträge
 
Delphi 11 Alexandria
 
#12

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 20. Okt 2023, 17:06
Kollision bei GUIDs dürften ungefähr so wahrscheinlich sein wie "Als ich meinen 10-Millionen-Gewinn im Lotto einlösen wollte, wurde ich vom Blitz getroffen, und der Beleg ist vollständig verbrannt."
Richtig, die Wahrscheinlichkeit ist verschwindend gering, aber nicht genau 0. Mir fällt auch kein einziger Anwqendungsfall ein, bei dem man das braucht, aber wenn er es wirklich braucht...
Sebastian Jänicke
Alle eigenen Projekte sind eingestellt, ebenso meine Homepage, Downloadlinks usw. im Forum bleiben aktiv!
  Mit Zitat antworten Zitat
Benutzerbild von dummzeuch
dummzeuch

Registriert seit: 11. Aug 2012
Ort: Essen
1.594 Beiträge
 
Delphi 10.2 Tokyo Professional
 
#13

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 20. Okt 2023, 17:15
War da bei von Windows generierten GUID nicht was mit der MAC-Adresse (einer) der Netzwerkkarten? Ich meine mich dunkel zu erinnern, dass die von Windows mit verwendet wird. Kann aber sein, dass das völliger Unsinn oder veraltet ist.
Thomas Mueller
  Mit Zitat antworten Zitat
Benutzerbild von paule32.jk
paule32.jk

Registriert seit: 24. Sep 2022
Ort: Planet Erde
356 Beiträge
 
Delphi 11 Alexandria
 
#14

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 20. Okt 2023, 17:16
es ging mir folgendes durch den Kopf:

- viele spielen doch mit ihren Daten und Programmen, und versehen dann Adressen oder
Offsets gerne mit:
Code:
$cafebabe oder:
$cafe     oder:
$babe     oder:
$affe
Frag doch einfach
Alles was nicht programmiert werden kann, wird gelötet
  Mit Zitat antworten Zitat
Rolf Frei

Registriert seit: 19. Jun 2006
646 Beiträge
 
Delphi 11 Alexandria
 
#15

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 21. Okt 2023, 12:42
Unter Windows ist die erzeugte GUID unter anderem auf der MAC-Adrese basierend und somit weltweit eindeutig. Du kannst niemals 2x die gleiche GUID bekommen.
  Mit Zitat antworten Zitat
Benutzerbild von paule32.jk
paule32.jk

Registriert seit: 24. Sep 2022
Ort: Planet Erde
356 Beiträge
 
Delphi 11 Alexandria
 
#16

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 21. Okt 2023, 12:49
du weißt aber schon, das man die MAC ändern kann ?
Frag doch einfach
Alles was nicht programmiert werden kann, wird gelötet
  Mit Zitat antworten Zitat
peterbelow

Registriert seit: 12. Jan 2019
Ort: Hessen
697 Beiträge
 
Delphi 12 Athens
 
#17

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 21. Okt 2023, 17:16
du weißt aber schon, das man die MAC ändern kann ?
Und? Das ist sowohl für bereits generierte als auch für neu generierte UIDs völlig irrelevant da die MAC-Adresse nicht das einzige ist, was in die Generierung einfließt.
Peter Below
  Mit Zitat antworten Zitat
Benutzerbild von stahli
stahli

Registriert seit: 26. Nov 2003
Ort: Halle/Saale
4.343 Beiträge
 
Delphi 11 Alexandria
 
#18

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 27. Okt 2023, 13:17
Ich habe mir für den Zweck eine eigene Guid aufgebaut.
Wichtig ist mir, dass diese global persistent eindeutig sind und dass die Reihenfolge (jedenfalls auf einem Rechner) aufsteigend nachvollziehbar ist.

Sie besteht aus zwei Zeitstempeln und einem fortlaufenden Zähler.
Der erste Zeitstempel enthält den Moment des Projektstarts (ist also so eine Art Session-ID), der zweite den Moment der ID-Erzeugung.
Der Zähler läuft bei jeder ID-Erzeugung weiter zwischen 0 bis 65535. So ist die Reihenfolge gut nachvollziehbar und es gibt noch eine Differenzierung falls doch mal beide Zeitstempel auf zwei Geräten gleich sein sollten.

Ich bin nicht auf die Standard-Guid angewiesen und so ist das für mich sinnvoller und nachvollziehbarer.
Sie braucht mit 18 Byte zwei Byte mehr als die Standard-Guid.

Delphi-Quellcode:
unit myGuid;

interface

  uses

    System.Classes;

  const

    MaxWord = 65535;

  type

    PmyGuid = ^TmyGuid;

    TmyGuid = record //: 18 Byte / 144 Bit
      C : Word; //: 2 Byte / 16 Bit
      TS1: TDateTime; //: 8 Byte / 64 Bit
      Ts2: TDateTime; //: 8 Byte / 64 Bit
      class function Create(const aGuid: PmyGuid): TmyGuid; overload; static;
      class function Create(const aGuid: String): TmyGuid; overload; static;
      class function Create(const aGuid: TmyGuid): TmyGuid; overload; static;
      class function CreateEmpty: TmyGuid; static;
      class function CreateNew: TmyGuid; static;
      class function StringIsValidGuid(const aGuid: String): Boolean; static;
      class operator Equal(const Left, Right: TmyGuid): Boolean;
      class operator NotEqual(const Left, Right: TmyGuid): Boolean; inline;
      function GetHashCode: Integer;
      function IsEmpty: Boolean;
      function ToString: String;
      procedure DoEmpty;
      procedure DoNew;
      procedure FromString(const aGuid: String);
      procedure ReadFromStream(const aStream: TMemoryStream);
      procedure WriteToStream(const aStream: TMemoryStream);
    end;

implementation

  uses

    System.SysUtils, System.DateUtils, System.Hash;

  var

    customTS1: TDateTime = 0;
    customTS2: TDateTime = 0;
    customC : Word = 0;

  {: *********************************** TmyGuid ********************************** :}

  {: ----------------------------------- default ---------------------------------- :}

  //: 2023-10-27
  class function TmyGuid.Create(const aGuid: String): TmyGuid;
  begin
    Result := TmyGuid.CreateEmpty;
    Result.FromString(aGuid);
  end;

  //: 2023-10-27
  class function TmyGuid.Create(const aGuid: TmyGuid): TmyGuid;
  begin
    Result := aGuid;
  end;

  //: 2023-10-27
  class function TmyGuid.Create(const aGuid: PmyGuid): TmyGuid;
  begin
    Result := aGuid^;
  end;

  //: 2023-10-27
  class function TmyGuid.CreateEmpty: TmyGuid;
  begin
    Result.TS1 := 0;
    Result.TS2 := 0;
    Result.C := 0;
  end;

  //: 2023-10-27
  class function TmyGuid.CreateNew: TmyGuid;
  begin
    customTS2 := Now;
    if (customC = MaxWord) then
      customC := 0
    else
      Inc(customC);
    Result.TS1 := customTS1;
    Result.TS2 := customTS2;
    Result.C := customC;
  end;

  //: 2023-10-27
  class function TmyGuid.StringIsValidGuid(const aGuid: String): Boolean;
  var
    I: Integer;
    C: Char;
  begin
    if (Length(aGuid) = 42) then
      begin
        Result := True;
        for I := 1 to Length(aGuid) do
          begin
            C := aGuid[I];
            case I of
              1:
                if C <> '#then
                  begin
                    Result := False;
                    Break;
                  end;
              19, 37:
                if C <> '-then
                  begin
                    Result := False;
                    Break;
                  end;
            else
              if not CharInSet(C, ['0'..'9']) then
                begin
                  Result := False;
                  Break;
                end;
            end;
          end;
      end
    else
      Result := False;
  end;

  //: 2023-10-27
  class operator TmyGuid.Equal(const Left, Right: TmyGuid): Boolean;
  begin
    Result := ((Left.TS1 = Right.TS1) and (Left.TS2 = Right.TS2) and (Left.C = Right.C));
  end;

  //: 2023-10-27
  class operator TmyGuid.NotEqual(const Left, Right: TmyGuid): Boolean;
  begin
    Result := ((Left.TS1 <> Right.TS1) or (Left.TS2 <> Right.TS2) or (Left.C <> Right.C));
  end;

  //: 2023-10-27
  function TmyGuid.GetHashCode: Integer;
  begin
    Result := 17;
    Result := Result * 397 + Integer(C);
    Result := Result * 397 + THashBobJenkins.GetHashValue(TS1, sizeOf(TDateTime), 5);
    Result := Result * 397 + THashBobJenkins.GetHashValue(TS2, sizeOf(TDateTime), 7);
  end;

  //: 2023-10-27
  function TmyGuid.IsEmpty: Boolean;
  begin
    Result := ((TS1 = 0) and (Ts2 = 0) and (C = 0));
  end;

  function TmyGuid.ToString: String;
  var
    S1, S2, S3: String;
  begin
    //: #yyyymmddhhnnsszzz-yyyymmddhhnnsszzz-xxxxx
    //: #12345678901234567890123456789012345678901 - > Length = 42
    if (TS1 = 0) then
      S1 := '00000000000000000'
    else
      S1 := FormatDateTime('yyyymmddhhnnsszzz', TS1);
    if (Ts2 = 0) then
      S2 := '00000000000000000'
    else
      S2 := FormatDateTime('yyyymmddhhnnsszzz', Ts2);
    if (C = 0) then
      S3 := '00000'
    else
      S3 := Format('%0.5d', [C]);
    Result := '#' + S1 + '-' + S2 + '-' + S3;
  end;

  //: 2023-10-27
  procedure TmyGuid.DoEmpty;
  begin
    TS1 := 0;
    TS2 := 0;
    C := 0;
  end;

  //: 2023-10-27
  procedure TmyGuid.DoNew;
  var
    lGuid: TmyGuid;
  begin
    lGuid := CreateNew;
    TS1 := lGuid.TS1;
    TS2 := lGuid.TS2;
    C := lGuid.C;
  end;

  //: 2023-10-27
  procedure TmyGuid.FromString(const aGuid: String);

    function EncodeTS(aGuid: String): TDateTime;
    var
      AYear, AMonth, ADay, AHour, AMinute, ASecond, AMilliSecond: Word;
    begin
      AYear := StrToInt(Copy(aGuid, 1, 4));
      AMonth := StrToInt(Copy(aGuid, 5, 2));
      ADay := StrToInt(Copy(aGuid, 7, 2));
      AHour := StrToInt(Copy(aGuid, 9, 2));
      AMinute := StrToInt(Copy(aGuid, 11, 2));
      ASecond := StrToInt(Copy(aGuid, 13, 2));
      AMilliSecond := StrToInt(Copy(aGuid, 15, 3));
      Result := EncodeDateTime(AYear, AMonth, ADay, AHour, AMinute, ASecond, AMilliSecond);
    end;

  begin
    if (StringIsValidGuid(aGuid)) then
      begin
        TS1 := EncodeTS(Copy(aGuid, 2, 17));
        Ts2 := EncodeTS(Copy(aGuid, 20, 17));
        C := StrToInt(Copy(aGuid, 38, 5));
      end
    else
      begin
        TS1 := 0;
        Ts2 := 0;
        C := 0;
      end;
  end;

  //: 2023-10-27
  procedure TmyGuid.ReadFromStream(const aStream: TMemoryStream);
  begin
    aStream.ReadData(C);
    aStream.ReadData(TS1);
    aStream.ReadData(Ts2);
  end;

  //: 2023-10-27
  procedure TmyGuid.WriteToStream(const aStream: TMemoryStream);
  begin
    aStream.WriteData(C);
    aStream.WriteData(TS1);
    aStream.WriteData(Ts2);
  end;

initialization

  customTS1 := Now;
  customTS2 := Now;
  customC := MaxWord;

end.
Stahli
http://www.StahliSoft.de
---
"Jetzt muss ich seh´n, dass ich kein Denkfehler mach...!?" Dittsche (2004)
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
43.993 Beiträge
 
Delphi 12 Athens
 
#19

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 27. Okt 2023, 13:34
ich bin mir fast sicher, dass die //: 18 Byte / 144 Bit so nicht stimmen
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Benutzerbild von stahli
stahli

Registriert seit: 26. Nov 2003
Ort: Halle/Saale
4.343 Beiträge
 
Delphi 11 Alexandria
 
#20

AW: TGUID - einzigartige ID auf andere Computer Systeme ?

  Alt 27. Okt 2023, 14:41
Oh, das stimmt.

SizeOf gibt 24 Byte an, bei TGuid nur 16.

Die einzelnen Werte sind ja aber korrekt:
Delphi-Quellcode:
  TmyGUID = record
      C : Word; //: 2 Byte
      TS1: TDateTime; //: 8 Byte
      TS2: TDateTime; //: 8 Byte
Summe=18
Delphi-Quellcode:
  TGUID = record
    D1: Cardinal; //: 4 Byte
    D2: Word; //: 2 Byte
    D3: Word; //: 2 Byte
    D4: array[0..7] of Byte; //: 8 Byte
Summe=16
Wo ist da mein Denkfehler bzw. Wissenslücke?
TGuid ist ja auch kein gepackter Record oder so?

Mir kam es bei meinen Überlegungen darauf an, ob es "verhältnismäßig" ist, eine eigene Guid zu verwenden.
Entsprechend hatte ich die einzelnen Variablen angesehen, die verwendet werden und bin auf die kaum höhere Größe gekommen.

Die reale Größe hatte ich dann gar nicht untersucht.


EDIT: Ok, mit "packed record" komme ich auf das erwartete Ergebnis.
Stahli
http://www.StahliSoft.de
---
"Jetzt muss ich seh´n, dass ich kein Denkfehler mach...!?" Dittsche (2004)

Geändert von stahli (27. Okt 2023 um 15:35 Uhr)
  Mit Zitat antworten Zitat
Antwort Antwort
Seite 2 von 7     12 34     Letzte »    


Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 00:51 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz