Printable View
I am familiar with CoCreateGUID and UUIDCreate methods of generating GUIDs. However, I was wondering if there was any technique for generating GUIDs where you could reproduce the results. Basically what I am looking for is a way to "seed" the GUID creation in such a way that I could reliably generate a series of GUIDs that was reproduceable after a seeding-type call was made.
Is there any technique for accomplishing this?
It wouldn't be much of a GUID, would it? However, if that's what you really want you can populate the _GUID structure yourself by probably using a seeded random number generator.
So you mean you want to keep the exact same GUI generation algorithm but you wanna be able to reproduce it?Quote:
Originally Posted by mercury529
If thats the case then you should find out exactly how GUID's are generated then it should be possible to reproduce them.
For instance, if the GUID is based on time and machinename then you should store the exact time and comp name you generated the GUID with and make the same algorithm as implemented by CoCreateGUID
siplier way just to store all generated for the program guids in some text file and read them from this file as neededQuote:
Originally Posted by KIBO
MarioF: I would not be using Microsoft's method of generating a GUID if I populated a GUID structure using random number info. The GUID I created would be an illegal GUID and could conflict with existing GUIDs.
KIBO: As far as I know, the method for generation of GUIDs is undocumented intentionally by Microsoft as is treated as proprietary. I may be wrong on this, but I thought that was the case.
Vart: I am currently using the technique you described. However, I want a sufficient backup in the case of file corruption to be able to retrieve the exact GUIDs I created.
I see a few uses for being able to reproduce the same GUIDs with a seeding function. In my current case, I am trying to generate Package Codes for an MSI installer. If my file that contains the package code GUIDs for every version remains in tact, there is no problem. However, if there is an occurence where my file and its backups are corrupted, I would like to be able to produce the same string of GUIDs programmatically.
use registryQuote:
Originally Posted by mercury529
Vart: I was hoping for a technique that as long as I had the same hardware, I would always be able to reproduce the same results. If I was forced to do a reinstall of the OS because of registry corruption (virus attack, etc), I would not want to lose the values. Although losing the backups as well is unlikely, I'd like to be as prepared as possible.
If there is a way to seed the GUIDs, it may have use in a custom encryption design as well.
If there was - it was not GUID... The main idea of the GUID - its uniqeness on any call to the generator in the near 10000 yearsQuote:
Originally Posted by mercury529
Well obviously in the background, as nothing is truly random, there must be an algorithm for generating the random components of the GUID. This algorithm either always generates the same "random" order of GUIDs, essentially an unseedable random number generation. Or the algorithm is in some way seedable to vary the randomness of the GUIDs it generates.
Essentially what I am hoping to find is a technique for seeding the background random component in such a way that I can generate the same GUID in much the same way you can seed a random number generator to always produce the same string of "random" results.
> Although losing the backups as well is unlikely, I'd like to be as prepared as possible.
If your backup fails to the point where this is an issue, the lack of your GUIDs will be the least of your problems.
If you ever get into such a state, simply recreate a new consistent set of GUIDs to use with the new installation.