Styjun

I am attempting to create 10,000 folders in a specific directory.
I have an algorithm for creating a random names for each folder.

The issue I am having is when I run this code, It stops with creating about 21 directories. The MessageBox.Show() is debug, however, it never pops up.

this.WorkingDir is a string property that looks like this.

"C:\Users\Reapism\Desktop\Yo\"

 DirectoryInfo directoryInfo;
 string dirName; // directory name
 const int dirNameLength = 15;

 for (int i = 0; i < 10000; i++) 
 dirName = GetRandomString(dirNameLength); // generates "unique name"
 try 
 directoryInfo = Directory.CreateDirectory(this.WorkingDir + dirName);
 catch (Exception e) 
 MessageBox.Show($"i dirName failed. e.ToString()");
 
 

 // Inserting a breakpoint here yields 21 directories

 DirectoryInfo d = new DirectoryInfo(this.WorkingDir);
 DirectoryInfo[] directories = d.GetDirectories($"*");

 foreach (DirectoryInfo dir in directories) 
 try 
 Directory.Delete(dir.FullName);
 catch (Exception e) 
 throw new FileNotFoundException($"Error deleting the directory!" + e.ToString());
 
 

The interesting thing is when I use the Debugger, and step through each iteration of the for loop in creating the directories, it goes further than 21 directories, and likely goes all the way to 10k. This would lead me to believe there is a limit to creating directories in a certain number of time.

Whats troubling is that no exception is thrown, the loop just discontinues.

Does this have to do with the CPU working quicker than the Disk can report or write a new Folder? If so, how can I get around this? This function is a timed function and using a Thread.Sleep(50) for example cannot be used.

EDIT The GetRandomString() was an issue. Below is the code of the non working GetRandomString() how do we fix it. We always pass in a constant integer into its argument. Does it have to do with Random creating the same seed?

 /// <summary>
 /// Generates a random string that may contain
 /// [a-z], [A-Z], and [0-9]. (62 characters.)
 /// </summary>
 /// <param name="length">The length of the string to generate</param>
 /// <returns></returns>
 /// <exception cref="ArgumentOutOfRangeException"></exception>

 private string GetRandomString(int length) 
 Random rnd = new Random();
 string rndStr = string.Empty;

 if (length < 1) 
 throw new ArgumentOutOfRangeException("Length must be greater than 0!");
 

 for (int i = 0; i < length; i++) 
 rndStr += this.charList[rnd.Next(this.charList.Length)];
 

 return rndStr;
 

If you want to see if you get similar results as me or different,
copy paste the code in your IDE. Note, I am using WPF and CLR v4.0.30319

Using statements:

using System;

using System.IO;

using System.Windows.Forms;

Your function GetRandomString generates non unique names, because you create new Random every times. You can use private class member Random which been created one times with class instance. I wrote sample counting unique names.

string[] dirNames = new string[10000];

for (i = 0; i < 10000; ++i)
 dirNames[i] = GetRandomString(dirNameLength); // generates "unique name";

foreach (var dr in dirNames.GroupBy(x => x).Select(x => new Name = x.Key, Count = x.Count() ).Where(x => x.Count > 1))

 Console.WriteLine($"dr.Count dr.Name");

Try this. Аnd don't forget that filenames are case insensitive, so you should use only 36 characters, not 62.

private static readonly char[] charList = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".ToCharArray();
private static readonly Random _random = new Random();

private static string GetRandomString(int length)

 if (length < 1)
 throw new ArgumentOutOfRangeException("Length must be greater than 0!");

 return new string(Enumerable.Repeat(charList, length).Select(s => s[_random.Next(s.Length)]).ToArray());

Regarding the update for GetRandomString()...

When you create a new instance of Random without passing it a seed, the default constructor will seed the new instance from Environment.TickCount - the time in milliseconds since the computer was started. Since this has a resolution of 1ms your code is most likely creating a lot of Random instances with the same seed value. This means that the method will return the same values every time until Environment.TickCount rolls over to the next value.

To solve this you should use a single Random instance and use that in all of the calls. Something like this should work:

private Random _rnd = null;

private string GetRandomString(int length) 

 if (_rnd == null)
 _rnd = new Random();

 if (length < 1) 
 throw new ArgumentOutOfRangeException("Length must be greater than 0!");

 var sb = new StringBuilder(length);
 for (int i = 0; i < length; i++)
 sb.Append(charList[_rnd.Next(charList.Length)]);
 return sb.ToString();

It does essentially the same as what you already have, but only creates a single Random instance. And avoids all that nasty string composition you have going on, so it'll be a tiny bit faster and more memory-friendly.

Another method, if you don't care about the actual names, would be to use Guid.NewGuid() to create guaranteed-unique values.

Probably your function GetRandomString throws an exception when executes real-time. Put it into try block and check. I tryed to create 10000 folders with names 1,2,3 ...10000 and I have created all.

 for (int i = 0; i < 10000; ++i)
 
 Directory.CreateDirectory(Path.Combine(WorkingDir, $"i"));