C# Random Number

Neither of the things you said you've tried should be "slow". Perhaps posting some code would help us help you find what's wrong. Also, what's the acceptance criteria for slow?

One thing it seems you have not tried is to call Random.Next in a way that will guarantee the number returned is 8 'chars' long: Random.Next(10000000, 100000000).

Looking at your original code:

You're creating a new random number generator in each loop. Create it once and keep calling the .Next() function it that.

As an aside, I just ran a test on my machine of the relative speeds of the approaches mentioned.

On my machine, this gives the following times:

Testing: Guffa1 00:00:05.2472507 Testing: Guffa2 00:00:03.6620228 Testing: Simple 00:00:03.7890637 Testing: Brian 00:00:01.8473002 Testing: JohnDagg 00:00:03.8853139 Testing: chsh 00:00:05.9960557 

The only approach that seems to really help is to skip over the StringBuilder and work directly from a character buffer

Code follows:

using System; using System.Text; using System.Diagnostics; class C { const int IterationCount = 10000000; static void Main() { Test("Guffa1", Guffa1); Test("Guffa2", Guffa2); Test("Simple", Simple); Test("Brian", Brian); Test("JohnDagg", JohnDagg); Test("chsh", chsh); } delegate string TestDelegate(Random rg); private static void Test(string name, TestDelegate testMethod) { Console.WriteLine("Testing: " + name); Random rg = new Random(0);//Start each test with the same random seed //Call the method once outside of the test to make sure the JIT has run etc. for(int i=0;i<1000000;++i) { testMethod(rg); } Stopwatch timer = new Stopwatch(); timer.Start(); for(int i=0;i<IterationCount;++i) { testMethod(rg); } timer.Stop(); Console.WriteLine(timer.Elapsed); } private static string Simple(Random rg) { return Convert.ToString(rg.Next(0, 99999999)).PadLeft(8, '0'); } private static string Brian(Random rg) { char[] fauxbuilder = new char[8]; int num = rg.Next(0, 100000000); for (int i = 0; i < 8; i++) { fauxbuilder[i] = (char)((num % 10) + 48); num /= 10; } return new string(fauxbuilder); } private static string Guffa1(Random rg) { StringBuilder builder = new StringBuilder(8); for (int i = 0; i < 8; i++) { builder.Append((char)rg.Next(48,58)); } return builder.ToString(); } private static string Guffa2(Random rg) { StringBuilder builder = new StringBuilder(8); int num = rg.Next(0, 100000000); for (int i = 0; i < 8; i++) { builder.Append((char)((num % 10) + 48)); num /= 10; } return builder.ToString(); } private static string JohnDagg(Random rg) { StringBuilder builder = new StringBuilder(8); byte[] b = new byte[8]; rg.NextBytes(b); for (int i = 0; i < 8; i++) { builder.Append((char)((b[i] % 10) + 48)); } return builder.ToString(); } private static string chsh(Random rg) { return ( NextSpecial(rg, 10000000) + NextSpecial(rg, 1000000) + NextSpecial(rg, 100000) + NextSpecial(rg, 10000) + NextSpecial(rg, 1000) + NextSpecial(rg, 100) + NextSpecial(rg, 10) + NextSpecial(rg, 1)) .ToString().PadLeft(8,'0'); } static int NextSpecial(Random rg, int multiplier) { return rg.Next(0, 10) * multiplier; } } 

It's likely in the scenario you describe that string operations are taking up as much or more time than the calls to Random.Next(). I have not tested the libraries, but converting the binary random-number to a decimal string is likely to be much slower than generating it. When you generate the string character-by-character this is even more likely to be the case.

So consider retaining the number as an int if possible, and then converting only for display purposes.

Well, I decided to try to beat Guffa :) I suspected his version had too much indirection. So, here's a variant on his solution, which uses a character array instead of a stringbuilder. It runs in about 70% of the time of his faster solution, when I benchmarked it via Stopwatch.

char[] fauxbuilder = new char[8]; int num = rnd.Next(0, 100000000); for (int i = 0; i < 8; i++) { fauxbuilder[i] = (char)((num % 10) + 48); num /= 10; } string code = new string(fauxbuilder); 

This should be quite efficient. It allocates a buffer of eight characters and adds characters to it. There is no extra step of turning each digit into a string and concatenating the strings, the characters are placed directly in the buffer. Then the buffer is returned in the form of a string, so there is no extra step of creating a string from the buffer either:

StringBuilder builder = new StringBuilder(8); for (int i = 0; i < 8; i++) { builder.Append((char)rnd.Next(48,58)); } string code = builder.ToString(); 

Turning a single random number into a string has the advantage of only calling the random generator once. You can make it faster by doing the conversion into a string yourself:

StringBuilder builder = new StringBuilder(8); int num = rnd.Next(0, 100000000); for (int i = 0; i < 8; i++) { builder.Append((char)((num % 10) + 48)); num /= 10; } string code = builder.ToString(); 

(Note that the second parameter to the Next method is not inclusive, so it should be 100000000 rather than 99999999. The number is actually rendered backwards into the string this way, but that doesn't matter as it's a random number.)

Similar to Guffa's answer, but perhaps faster on a nanoscale level since it avoid "costly" division.

 Random rnd = new Random(); StringBuilder builder = new StringBuilder(8); byte[] b = new byte[8]; rnd.NextBytes(b); for (int i = 0; i < 8; i++) { builder.Append((char)((b[i] % 10) + 48)); } string code = builder.ToString(); 

This code is what I hacked together as a solution and has no real optimization (other than initializing the list to the known size). On my system over repeated tests it was sub-1 second. I have it write out the file at the end for quality control purposes. It seems like it generates what you're looking for, but feel free to point out any flaws.

 static Random rand = new Random(); static int NextSpecial(this Random r, int multiplier) { return r.Next(0, 10) * multiplier; } static string randomString() { return (rand.NextSpecial(10000000) + rand.NextSpecial(1000000) + rand.NextSpecial(100000) + rand.NextSpecial(10000) + rand.NextSpecial(1000) + rand.NextSpecial(100) + rand.NextSpecial(10) + rand.NextSpecial(1)) .ToString().PadLeft(8,'0'); } static void Main() { int MAXITEMS = 1000000; IList<string> numbers = new List<string>(MAXITEMS); Stopwatch sw = new Stopwatch(); sw.Start(); for (int i = 0; i < MAXITEMS; i++) { numbers.Add(randomString()); } sw.Stop(); Console.WriteLine("{0} iterations took: {1}", MAXITEMS.ToString(), sw.Elapsed); File.WriteAllLines(@"c:\test.txt", numbers.ToArray()); Console.ReadLine(); }