c#产生随机数的四种方式

Random快速连续产生相同随机数的四种方式：
1、默认方式产生随机数种子（DateTime.Now.Ticks）
优点：速度快
　　缺点：如果短时间内连续调用，就有可能造成产生一样的随机数
　　
2、使用默认方式产生随机数，但两次调用之间使用Thread.Sleep()延迟几个毫秒，防止由于计算机运算速度过快，产生相同随机数；
　　缺点：速度慢。
　　
3、使用RNGCryptoServiceProvider生成Seed；加密随机数生成器生成Random的Seed种子
　　速度较 1，2种方式慢，但适合短时间内生成大量随机数
　　
4、使用Guid生成Seed；

//改自：https://blog.csdn.net/cjolj/article/details/59484045
//改写：鸟哥 qq1833183060

using System;
using System.Diagnostics;
using System.Threading;

namespace CSharp生成随机数
{
    class Program
    {
        /// 

        /// 使用RNGCryptoServiceProvider生成种子
        /// 
        /// 
        static int GetRandomSeed()
        {
            byte[] bytes = new byte[4];
            System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
            rng.GetBytes(bytes);
            return BitConverter.ToInt32(bytes, 0);

        }
        /// 

        /// 使用Guid生成种子
        /// 
        /// 
        static int GetRandomSeedbyGuid()
        {
            return Guid.NewGuid().GetHashCode();
        }

        /// 

        /// 默认方式产生随机数种子
        /// 
        static void GetRandomDefault(int[] array)
        {
            int len = array.Length;
            Random random = new Random();

            for (int i = 0; i < len; i++)
            {
                
                array[i] = random.Next(0, len);
            }
            //Print(array);// 输出生成的随机数
        }
        /// 

        /// 使用Thread.Sleep()方式产生真随机数
        /// 
        static void GetRandomBySleep(int[] array)
        {
            int len = array.Length;
            Random random = new Random();

            for (int i = 0; i < len; i++)
            {
                Thread.Sleep(1);
                array[i] = random.Next(0, len);
            }
            //Print(array);// 输出生成的随机数
        }
        /// 

        /// 使用RNGCryptoServiceProvider产生的种子生成真随机数
        /// 
        static void GetRandomByRNGCryptoServiceProvider(int[] array)
        {
            int len = array.Length;
            Random random = new Random(GetRandomSeed());
            for (int i = 0; i < len; i++)
            {

                array[i] = random.Next(0, len);
            }
            //Print(array);// 输出生成的随机数
        }
        /// 

        /// 使用Guid产生的种子生成真随机数
        /// 
        static void GetRandomByGuid(int[] array)
        {
            int len = array.Length;
            Random random = new Random(GetRandomSeedbyGuid());
            for (int i = 0; i < len; i++)
            {
                array[i] = random.Next(0, len);
            }
            //Print(array);// 输出生成的随机数
        }
        static void Print(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
                Console.Write(string.Format("{0} ", array[i]));
            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            int[] array = new int[400];
            Stopwatch sw = new Stopwatch();

            sw.Start();
            GetRandomDefault(array);
            sw.Stop();
            TimeSpan ts = sw.Elapsed;
            Console.WriteLine("使用默认方式总共花费{0}ms.", ts.TotalMilliseconds);
            sw.Reset();
            
            
            sw.Start();
            GetRandomBySleep(array);
            sw.Stop();
            ts = sw.Elapsed;
            Console.WriteLine("使用Thread.Sleep(1)总共花费{0}ms.", ts.TotalMilliseconds);
            sw.Reset();

            sw.Start();
            GetRandomByRNGCryptoServiceProvider(array);
            sw.Stop();
            ts = sw.Elapsed;
            Console.WriteLine("使用RNGCryptoServiceProvider生成种子，产生随机数总共花费：{0}ms.", ts.TotalMilliseconds);
            sw.Reset();

            sw.Start();
            GetRandomByGuid(array);
            sw.Stop();
            ts = sw.Elapsed;
            Console.WriteLine("使用Guid生成种子，产生随机数总共花费：{0}ms.", ts.TotalMilliseconds);

            Console.ReadLine();
        }
    }
}

运行结果：

使用默认方式总共花费0.3067ms.
使用Thread.Sleep(1)总共花费430.1739ms.
使用RNGCryptoServiceProvider生成种子，产生随机数总共花费：0.7531ms.
使用Guid生成种子，产生随机数总共花费：14.7704ms.