C＃随机数棘手问题

Question

本来想随即生成一个25位长的随机数，但是C＃就是不听使唤，请帮忙看看问题所在
代码
private string createSN()
{
  string[] sn = new string[25];
  string returnString = "YJ";
  for(int i=2; i<25;i++)
  {
    sn[i] = this.getRabdom(0,9).ToString();
  }
  for(int i=2; i<25;i++)
  {
    returnString += sn[i];
  }
  return returnString;
}private int getRabdom(int min, int max)
  Random ran = new Random();
  return ran.Next(min,max);
}正常运行情况下发现后面23位数每次都相同
调试状态下，一切正常，都是生成各自的随机数

Answer 1

Random rd = new Random(Guid.NewGuid().GetHashCode());
or：
Random r = new Random(unchecked((int)DateTime.Now.Ticks));

Answer 2

Random ran = new Random();private string createSN()
{
  string[] sn = new string[25];
  string returnString = "YJ";
  for(int i=2; i<25;i++)
  {
    sn[i] = this.getRabdom(0,9).ToString();
  }
  for(int i=2; i<25;i++)
  {
    returnString += sn[i];
  }
  return returnString;
}private int getRabdom(int min, int max)
  
  return ran.Next(min,max);
}

Answer 3

把
Random ran = new Random();
这句抽出来，定义为成员例如：
private Random ran = new Random();

Answer 4

种子一样，C#中的随机序列就一样。
Random ran = new Random();默认以当前时间为种子。  Random ran = new Random();
  return ran.Next(min,max);运行时，可能种子都是一样的，相当于都是去随机序列的第一个数，当然一样了。
调试时，种子就变了。随机序列才变。设置成全局变量，取随机数的序列中的下一个数。

Answer 5

private string GenerateCheckCode()
{
int number;
char code;
string checkCode = String.Empty;
System.Random random = new Random();
for(int i=0; i<5; i++)
{
number = random.Next();
if(number % 2 == 0)
code = (char)('0' + (char)(number % 10));
else
code = (char)('A' + (char)(number % 26));
checkCode += code.ToString();
}
Response.Cookies.Add(new HttpCookie("CheckCode", checkCode));
return checkCode;
}

Answer 6

public string RandomNum(int n) 
 {
 string strchar = "0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z" ;
            string[] VcArray = strchar.Split(',') ;
            string  VNum = "" ;   //由于字符串很短，就不用StringBuilder了
            int temp = -1 ;     //记录上次随机数值，尽量避免产生几个一样的随机数
                                    //采用一个简单的算法以保证生成随机数的不同
            Random rand =new Random();
            for ( int i = 1 ; i < n+1 ; i++ ) 
            {   
                if ( temp != -1) 
                {
                    rand =new Random(i*temp*unchecked((int)DateTime.Now.Ticks));
                }   
                  int t=rand.Next(36);
                if (temp != -1 && temp == t) 
                {                
                    return RandomNum(n);
                }
                temp = t  ;
                VNum += VcArray[t];
            }
            return VNum ;//返回生成的随机数
        }
这是产生带字母的你要多长都可以　不要字母就把数组里的能了

Answer 7

private Random ran = new Random();

Answer 8

随机数是以时间为种子的，楼主循环生成，CPU运行的太快，所以会出现重复的字符串提供一个方法给楼主，试看看
1、在类中定义一个全局变量：
static Random Rnd=new Random();2、方法 public static string CodeBuild()
{
try
{
System.Threading.Thread.Sleep(1);//延时一毫妙
string code=DateTime.Now.Year.ToString()+DateTime.Now.Month.ToString()+DateTime.Now.Day.ToString()+DateTime.Now.Hour.ToString()+DateTime.Now.Minute.ToString()+DateTime.Now.Second.ToString()+DateTime.Now.Millisecond.ToString();
if(code.Length<17)
{
for(int i=0;i<17-code.Length;i++)
{
code=code+"0";
}
}
string ran=Rnd.Next(10000000,99999999).ToString();//生成一个8位的10000000到99999999之间的随机数
code=code+ran;
if(code.Length<25)
{
for(int i=0;i<25-code.Length;i++)
{
code=code+"8";
}
}
return code;
}
catch(Exception e)
{
throw (e);
}
}

Answer 9

循环调用CodeBuild()方法，因为有延时1毫妙，所以不会产生重复的字符串

Answer 10

不如通过GUID来解决,GUID是四个整数,四个整数平铺开,长度至少要比25位长N多.
可以把GUID每四个字节分一组,组四个整数,
显后把四个整数格式化成四个7位的10进制数,然后,随机从中删掉3个数码.

Answer 11

//给你一个刚写的函数，生成定长随机数字符串，测试过，速度还挺快
string GetRandomNumString(int length)
{
    StringBuilder sbd = new StringBuilder();
    if (length <= 0)
    {
        throw new ArgumentException("个数必须大于0","length");
    }
    byte[] buffer = new byte[length*4];
    System.Security.Cryptography.RandomNumberGenerator.Create().GetBytes(buffer);
    for (int i=0; i<length; i++)
    {
        sbd.Append(Math.Abs(BitConverter.ToInt32(buffer,i*4))%10);
    }
    return sbd.ToString();
}

Answer 12

问题已经解决了，谢谢各位的帮助但我还是不明白，既然是以时间为种子，那么如果CPU的时间要是足够快的话，快到连滴答单位都没有办法区分，那么生成的随机数还是一样的吗？还有，Knight94(愚翁)等的方法，只实例化一个Random对象（把一个Random作为字段）也可以解决问题，难道这样代码的运行时间就更慢吗？

Answer 13

to 但我还是不明白，既然是以时间为种子，那么如果CPU的时间要是足够快的话，快到连滴答单位都没有办法区分，那么生成的随机数还是一样的吗？你最好看看MSDN中对于Random默认构造函数地解释就会明白。

Answer 14

MSDN上说:
The default seed value is derived from the system clock. However, when generating random numbers on high-performance systems, the system clock value might not produce the expected behavior.
就是说两次Random的构造函数调用的时间间格快到1豪秒都没有..使得两次的种子相同.MSDN上的实例解决办法是睡它1豪秒再new..        // Wait to allow the timer to advance.
        Thread.Sleep( 1 );        Console.WriteLine( 
            "\nRandom numbers from a Random object " +
            "with an auto-generated seed:" );
        Random autoRand = new Random( );

Answer 15

种子的问题,用时间DateTime.now来当参数吧.

Answer 16

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Security.Cryptography;namespace randnumber
...{
     class randnumber
    ...{
        /**//// <summary>
        /// 产生随机数的个数
        /// </summary>
         public  int num;
         /**//// <summary>
         /// 随机数存储的数组
         /// </summary>
         public double[] randnum;         /**//// <summary>
         /// 构造函数
         /// </summary>
          public  randnumber(int num)
         ...{
             this.num = num;
             randnum = new double[this.num];
         }
         /**//// <summary>
         /// 产生随机数，填充数组
         /// </summary>
         /// <returns>产生0--1之间的随机数，填充数组</returns>
         private     void  RundoubleRandoms(Random randObj )
        ...{
            
             
             for (int i=0; i < num; i++)
               ...{
                   randnum[i] = randObj.NextDouble();
                 
               }
               
                 
        }
        /**//// <summary>
        /// 利用系统时间产生随机数
        /// </summary>
        /// <res>调用RundoubleRandoms方法填充数组</res>
        public    void  AutoSeedRandoms()
         ...{
                         
             Random autoRand = new Random();             RundoubleRandoms(autoRand);
         }         /**//// <summary>
         /// 产生一串随机的密码串
         /// </summary>
         public  string GetRandomPassword(int length)
         ...{
             byte[] random = new Byte[length / 2];
             RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
             rng.GetNonZeroBytes(random);             StringBuilder sb = new StringBuilder(length);             for (int i = 0; i < random.Length; i++)
             ...{
                 sb.Append(String.Format("{0:X2}", random[i]));
             }
             return sb.ToString();
         }    }
}  这其中包含一个用。net中的密码生成创建一个随机的密码串

Answer 17

kissed() ( ) 信誉：100    Blog  2006-8-25 19:39:44  得分: 0  
不用说我的是最好的请问效率如何,您测试过吗?比如10万中取8万...
  
 

Answer 18

但我还是不明白，既然是以时间为种子，那么如果CPU的时间要是足够快的话，快到连滴答单位都没有办法区分，那么生成的随机数还是一样的吗？
===============================================
如果不指定参数,第一次创建Random时,以当时的时间为种子,以后会以上次产生的数字作为下一次的种子,这样,你创建一个实例的话,用它去生成随机数不会出错.
估计调试时比较慢,所以重复实例化Random时时间不同,而正常运行时速度很快,重复实例化时每次得到的时间相同,导致错误产生.

Answer 19

C#好像已经默认了以时间为种子产生随机数吧，那么再用时间作种子有意义吗？？如果随机数是连续产生的，那么如果CPU运行得太快，也有可能会产生出相同的。。小菜鸟在想可不可以自己用随机数作为种子，来产生新的随机数？？望各位高手指点。

Answer 20

两次生成Random对象咯...
第一次用默认构造生成,然后取几个随机数做种子,再构造一个Random...
应该没问题...

Answer 21

两次生成Random对象咯...
第一次用默认构造生成,然后取几个随机数做种子,再构造一个Random...
应该没问题...
========================
要注意,两次生成的Random实例的话,如果时间间隔足够小,那么...他们产生的随机数是一样的,
你再分别以这两个相同的随机数为种子...出来的下一个随机数依然是相同的,重复N次也是一样的,
而且你没必要以产生的随机数为种子再构造Random,因为Random下次产生时本来就是以上次的随机数为种子的,自己构造的话,反倒多了一个环节,影响性能;
所以,关键是在几乎同时生成随机数的时候,最好的选择就是用一个Random依次生成所需的随机数