澳门赌场

法式开辟 > C# > 注释

C#发生指定规模随机数(整数、小数、字符、布尔,相对不反复的和独一的)的几种体例

亮术网 2019-01-19 本网首创

在开辟进程中,经常要发生随机数,如天生静态 html 网页时,文件名凡是用发生随机数的体例获得,天生订单的时辰,订单号也能够用发生随机数的体例获得等。

在 C# 中,普通都用 Random 发生随机数,它可肆意指定发生随机数规模。Random 连系数组,能够发生一些特别规模的随机数,以知足特别的须要。若是在轮回中发生随机数,因为距离时辰短,每次发生的随机数都一样,须要先天生种子(有 3 种体例),再用该种子发生随机数,或锁住 Random 工具,如许能力削减发生随机数的反复率。若是要发生独一的随机数(有 4 种体例),须要用数组或查抄已发生随机数是不是反复的方式。

 

一、用 Random 发生指定规模随机数(整数随机数)

1、发生指定下限的随机数(如发生100之内的随机数)

Random ran = new Random();

int n = ran.Next(100);

 

2、发生指定上下限的随机数(如发生100到1000的随机数)

Random ran = new Random();

int n = ran.Next(100, 1000);

 

二、用 Random 连系数组发生指定规模随机数(字符和布尔随机数)

在某些环境下,随机数只能取一些特别指定的值,如不持续的数字或指定的一些单词等,此时仅用 Random 没法到达请求,必须借住数组能力完成。完成思绪大要是如许:先把这些特别的值存到数组中,而后把数组的长度作为 Random 的下限发生随机数,此随机数恰是数组的下标,按照该下标获得数组的值。

(一)发生字符随机数

1、发生不持续或指定值的随机数

代码以下:

public string GetRandom(string[] arr)
  {
    Random ran = new Random();
    int n = ran.Next(arr.Length - 1);
    return arr[n];
  }

挪用体例:

string[] arr = { "25", "28", "30", "50", "60" };
  GetRandom(arr);

 

2、天生保留指定小数位数(比方 2 位)的随机数

假设要用指订单词作为随机数的取值,代码完成跟上例不异,所差别的仅是随机数的取值,以是只需界说一个单词数组间接挪用下面代码便可。

挪用体例:

string[] arr = { "red", "green", "blue", "orange", "white" };
  GetRandom(arr);

 

(二)发生布尔随机数

public bool GenerateBoolRandom()
  {
    bool[] arr = { true, false };
    Random ran = new Random();
    return arr[ran.Next(2)];
  }

挪用体例:

Response.Write(GenerateBoolRandom());// 成果 true

 

 

三、用 Random 发生小数随机数

在默许环境下,C# 只能发生肆意小数随机数,若是要发生指定规模小数随机数,须要本身写代码。写代码时,既能够把它们封装到一个体例中又能够封装到一个类中,后者可重载 C# 的 NextDouble() 体例。

1、把代码封装到一个体例

A、天生小数随机数

public double NextDouble(Random ran, double minValue, double maxValue)
  {
     return ran.NextDouble() * (maxValue - minValue) + minValue;
  }

挪用:

Random ran = new Random();
  double randNum = NextDouble(ran, 1.52, 2.65);
  Response.Write(randNum);// 成果 2.30927768119112

 

B、天生保留指定小数位数(比方 2 位)的随机数

public double NextDouble(Random ran, double minValue, double maxValue, int decimalPlace)
  {
     double randNum = ran.NextDouble() * (maxValue - minValue) + minValue;
     return Convert.ToDouble(randNum.ToString("f" + decimalPlace));
  }

挪用:

Random ran = new Random();
  double randNum = NextDouble(ran, 5.16, 8.68, 2);// 保留两位小数
  Response.Write(randNum);// 成果 8.46

 

2、把代码封装到一个类

代码:

using System;
  using System.Text;

public static class RandomDoubleRange
  {
    public static double NextDouble(this Random ran, double minValue, double maxValue)
    {
      return ran.NextDouble() * (maxValue - minValue) + minValue;
    }

  public static double NextDouble(this Random ran, double minValue, double maxValue, int decimalPlace)
    {
      double randNum = ran.NextDouble() * (maxValue - minValue) + minValue;
       return Convert.ToDouble(randNum.ToString("f" + decimalPlace));
    }
  }

挪用:

Random ran = new Random();
  double randNum1 = ran.NextDouble(5.16, 8.68);
  double randNum2 = ran.NextDouble(5.16, 8.68, 2);//保留两位小数
  Response.Write(randNum1 + "; " + randNum2);//成果 7.41055195257559; 6.69

 

四、发生相对不反复的随机数

当在一个轮回中天生随机数,因为天生随机数的时辰距离比拟短,轻易发生反复的随机数,若是要发生不反复的随机数,须要用种子或把随机数工具锁住,以下是它们的完成体例。

1、用种子发生相对不反复的随机数

天生种子体例一:

public static int GenerateRandomSeed()
  {
    return (int)DateTime.Now.Ticks;
  }

发生 1 到 10 的随机数为:2, 5, 2, 5, 7, 3, 4, 4, 6, 3

 

天生种子体例二:

using System.Text.RegularExpressions;

public static int GenerateRandomSeed()
  {
    return Convert.ToInt32(Regex.Match(Guid.NewGuid().ToString(), @"\d+").Value);
  }

发生 1 到 10 的随机数为:1, 7, 4, 9, 8, 1, 8, 7, 9, 8

 

天生种子体例三:

using System.Security.Cryptography;

public static int GenerateRandomSeed()
  {
    byte[] bytes = new byte[4];
    RNGCryptoServiceProvider rngCSP = new RNGCryptoServiceProvider();
    rngCSP.GetBytes(bytes);
    return BitConverter.ToInt32(bytes, 0);
  }

发生 1 到 10 的随机数为:4, 8, 7, 2, 6, 7, 6, 5, 5, 7

 

发生指定数量的随机数并存到数组:

// randNum 为发生随机数的数量
    public int[] GenerateRandom(int minValue, int maxValue, int randNum)
    {
        Random ran = new Random(GenerateRandomSeed());
        int[] arr = new int[randNum];

    for (int i = 0; i < randNum; i++)
        {
            arr[i] = ran.Next(minValue, maxValue);
        }
        return arr;
    }

挪用体例:

int[] arr = GenerateRandom(1, 10, 10);
  string temp = string.Empty;
  for (int i = 0; i < arr.Length; i++)
  {
    temp += arr[i].ToString() + ", ";
  }
  Response.Write(temp);

 

2、经由过程锁住 Random 工具发生相对不反复的随机数

发生随机数:

public int GenerateRandom(Random ran, int minValue, int maxValue)
  {
    lock (ran) // 锁住 Random 工具
    {
      return ran.Next(minValue, maxValue);
    }
  }

挪用:

int[] arr = new int[5];
  Random ran = new Random();
  for (int i = 0; i < 5; i++)
  {
    arr[i] = GenerateRandom(ran, 1, 10);// 成果 5, 7, 2, 5, 2
   }

 

 

五、天生相对不反复的指定规模的随机数

1、体例一:先天生一个索引数组,再把发生的随机数作为索引从该数组中取一个数作为随机数。

天生随机数:

// n 为天生随机数个数
  public int[] GenerateUniqueRandom(int minValue, int maxValue, int n)
  {
    //若是天生随机数个数大于指定规模的数字总数,则最多只天生该规模内数字总数个随机数
    if (n > maxValue - minValue + 1)
      n = maxValue - minValue + 1;

  int maxIndex = maxValue - minValue + 2;// 索引数组下限
    int[] indexArr = new int[maxIndex];
    for (int i = 0; i < maxIndex; i++)
    {
      indexArr[i] = minValue - 1;
      minValue++;
    }

  Random ran = new Random();
    int[] randNum = new int[n];
    int index;
    for (int j = 0; j < n; j++)
    {
      index = ran.Next(1, maxIndex - 1);// 天生一个随机数作为索引

      //按照索引从索引数组中取一个数保管到随机数数组
      randNum[j] = indexArr[index];

      // 用索引数组中最初一个数代替已当选作随机数的数
      indexArr[index] = indexArr[maxIndex - 1];
      maxIndex--; //索引下限减 1
    }
    return randNum;
  }

挪用体例:

GenerateUniqueRandom(1, 10, 10);// 成果 9, 5, 10, 1, 7, 3, 2, 4, 6, 8

GenerateUniqueRandom(1, 10, 5);// 成果 3, 7, 6, 1, 9

 

2、体例二:do...while 轮回来天生不反复的随机数,用 for 轮回来查抄发生的随机数是不是反复,只要不反复的随机数才保管到数组。

天生随机数:

// n 天生随机数个数
  public int[] GenerateUniqueRandom(int minValue, int maxValue, int n)
  {
    // Random.Nex(1, 10) 只能发生到 9 的随机数,若要发生到 10 的随机数, maxValue 要加 1
    maxValue++;

  // Random.Nex(1, 10) 只能发生 9 个随机数,是以 n 不能大于 10 - 1
    if (n > maxValue - minValue)
      n = maxValue - minValue;

  int[] arr = new int[n];
    Random ran = new Random((int)DateTime.Now.Ticks);

  bool flag = true;
    for (int i = 0; i < n; i++)
    {
      do
      {
        int val = ran.Next(minValue, maxValue);
        if (!IsDuplicates(ref arr, val))
        {
          arr[i] = val;
          flag = false;
        }
      } while (flag);
      if (!flag)
        flag = true;
    }
    return arr;
  }

// 查检以后天生的随机数是不是反复
  public bool IsDuplicates(ref int[] arr, int currRandNum)
  {
    bool flag = false;
    for (int i = 0; i < arr.Length; i++)
    {
      if (arr[i] == currRandNum)
      {
        flag = true;
        break;
      }
    }
    return flag;
  }

挪用体例:

int[] arr = GenerateUniqueRandom(1, 10, 10);// 天生 10 个 1 到 10 的随机数
  for (int i = 0; i < arr.Length; i++)
  Response.Write(arr[i] + ", ");// 成果 10, 7, 9, 4, 3, 5, 1, 2, 6, 8

GenerateUniqueRandom(1, 10, 5);// 天生 5 个 1 到 10 的随机数,成果 9, 1, 7, 2, 10

 

3、体例三:do...while 轮回来查抄发生的随机数是不是反复,只要不反复的随机数才保管到哈希表。

天生随机数:

using System.Collections;

// n 为天生随机数个数
  public Hashtable GenerateUniqueRandom(int minValue, int maxValue, int n)
  {
    // Random.Next(1, 10) 只能发生到 9 的随机数,若要发生到 10 的随机数,maxValue 要加 1
    maxValue++;

  // Random.Next(1, 10) 只能发生 9 个随机数,是以 n 不能大于 10 - 1
    if (n > maxValue - minValue)
      n = maxValue - minValue;

  Hashtable ht = new Hashtable();
    Random ran = new Random((int)DateTime.Now.Ticks);

  bool flag = true;
    for (int i = 0; i < n; i++)
    {
      do
      {
        int val = ran.Next(minValue, maxValue);
        if (!ht.ContainsValue(val))
        {
          ht.Add(i, val);
          flag = false;
        }
      } while (flag);
      if (!flag)
        flag = true;
    }
    return ht;
  }

挪用体例:

Hashtable ht = GenerateUniqueRandom(1, 10, 10);// 天生 10 个 1 到 10 的随机数
  foreach (DictionaryEntry de in ht)
  Response.Write(de.Value.ToString() + ", ");// 成果 10, 7, 9, 4, 3, 5, 1, 2, 6, 8

GenerateUniqueRandom(1, 10, 5);// 天生 5 个 1 到 10 的随机数,成果 4, 10, 9, 7, 6

 

4、体例四:用 Linq 天生不反复的随机数

天生随机数:

using System.Linq;

public IEnumerable<int>
  GenerateNoDuplicateRandom(int minValue, int maxValue)
  {
    return Enumerable.Range(minValue, maxValue).OrderBy(g => Guid.NewGuid());
  }

挪用体例:

IEnumerable<int> list = GenerateNoDuplicateRandom(1, 10);
  string str = string.Empty;
  foreach (int item in list)
  {
    str += item.ToString() + ", ";
  }
  Response.Write(str);// 成果 5, 2, 10, 1, 7, 6, 8, 3, 9, 4

以上几种发生指定随机数的体例,都经由过程测试,可按照现实开辟须要矫捷挑选,普通环境都是间接用 Random 便能够了。

本文稀释标签:随机数C#