What are the chances to get a Guid.NewGuid () duplicate? [duplicate]

Answer 1

You will definitely run out of disk space or jam the filesystem before GUIDs collide. Just handle errors when creating files gracefully and you'll be fine.

Answer 2

There is always some miniscule chance of duplicates, but Globally Unique Identifiers are meant to be just that: globally unique ...not system-wide unique, but as in the Planet Earth unique.

I speculate that, theoretically, you have a better chance of duplicating a UUID across multiple systems, than on a single system. While the OS isn't going to store each GUID that it generates, it probably uses some time based seed data to avoid collisions in itself. Of course this is dependent on the implementation.

Oh, and chances...well there are 3.4 x 10^38 available, Wikipedia says you're more likely to get hit by a meteorite.

I'll also offer an alternative method, the Path.GetTempFileName() method may be worth looking into, because it has protection against collision...though it can only create 65,535 unique file names before throwing an exception if previous files aren't deleted.

Other than that, it's not very difficult to do:

string path;

do
{
    path = Guid.NewGuid().ToString(); // Format as needed

} while (File.Exists(path));

Answer 3

The chances of getting two identical guids are astronomically slim even if you are generating guids as fast as you can. (Generating, say, thousands of guids per second for the sole purpose of finding a duplicate.)

Of course, if you want my opinion, I do believe that there will be a time, in a couple of thousand years from now, when we will be colonizing the galaxy, our population will be in the trillions, the number of individual computers embedded everywhere will number in the gazillions, and every single one of those computers will be generating GUIDs at a rate which is unthinkable today, when we will start running into trouble with duplicate guids popping up every once in a while in distant areas of the galaxy, and then it will be like 640k of memory all over again, DLL hell all over again, two-digit-year millenium bug all over again, all of them combined.

The thing with GUIDs is that we don't want them to be huge, because then they would be wasteful, so someone had to come up with a number of bits that is small enough to not be too wasteful and yet large enough to give a reasonable guarantee against collisions. So, it is a technological compromise. In our century 128 bits seem to be a good compromise, but with almost mathematical certainty there will be another century when this compromise will not be so good anymore.

Answer 4

Please read the following question for info about collisions: Are GUID collisions possible?

Regarding the "one guid per second", generated guids usually take time into account, so on the same computer, 0 chance to generate the same guid unless you change the settings of the internal clock

edit: apparently the wikipedia page about guids says that time is not mandatory when building a guid so i guess it depends on the algorithm used. Since we're talking C# (on windows?) it's in fact a UUID which does include timing in some versions.

Answer 5

You would never run out of guids. The likelihood of duplicating them is VERY low:

http://betterexplained.com/articles/the-quick-guide-to-guids/

Answer 6

You should not worry about getting duplicate GUID when you are creating it every second. You can refer to http://en.wikipedia.org/wiki/Universally_unique_identifier and read the probability of duplicate GUID.