生成随机的、唯一的值C#

我已经搜索了一段时间，并一直在努力寻找这个，我试图生成几个随机的，唯一的数字是C。我使用的是

System.Random

，我使用的是

DateTime.Now.Ticks

seed:

public Random a = new Random(DateTime.Now.Ticks.GetHashCode());
private void NewNumber()
{
    MyNumber = a.Next(0, 10);
}

我经常打电话给

NewNumber（）

，但问题是我经常收到重复的号码。有些人建议，因为我每次都声明随机数，它不会产生随机数，所以我将声明放在函数之外。有什么建议或比使用

系统更好的方法吗？多谢各位

我经常打电话给NewNumber（），但问题是我经常
重复的数字

Random.Next
不保证数字是唯一的。此外，您的范围是从0到10，很可能会得到重复的值。可能是，您可以设置一个
int
列表，并在检查列表是否不包含重复项后在列表中插入随机数。比如：

public Random a = new Random(); // replace from new Random(DateTime.Now.Ticks.GetHashCode());
                                // Since similar code is done in default constructor internally
public List<int> randomList = new List<int>();
int MyNumber = 0;
private void NewNumber()
{
    MyNumber = a.Next(0, 10);
    if (!randomList.Contains(MyNumber))
        randomList.Add(MyNumber);
}

public Random a=new Random（）；//从新随机（DateTime.Now.Ticks.GetHashCode（））替换；
//因为类似的代码是在默认构造函数内部完成的
public List randomList=新列表（）；
int MyNumber=0；
私有void NewNumber（）
{
MyNumber=a.Next（0,10）；
如果（！randomList.Contains（MyNumber））
随机列表。添加（MyNumber）；
}
如果范围仅为0到9，则可以尝试对可能的整数数组进行无序排列。这增加了避免数字生成中任何冲突的好处

var nums = Enumerable.Range(0, 10).ToArray();
var rnd = new Random();

// Shuffle the array
for (int i = 0;i < nums.Length;++i)
{
    int randomIndex = rnd.Next(nums.Length);
    int temp = nums[randomIndex];
    nums[randomIndex] = nums[i];
    nums[i] = temp;
}

// Now your array is randomized and you can simply print them in order
for (int i = 0;i < nums.Length;++i)
    Console.WriteLine(nums[i]);

var nums=Enumerable.Range（0,10）.ToArray（）；
var rnd=新随机数（）；
//洗牌
对于（整数i=0；i
根据您的实际情况，您可以执行以下操作：

using System;
using System.Collections.Generic;
using System.Linq;

namespace SO14473321
{
    class Program
    {
        static void Main()
        {
            UniqueRandom u = new UniqueRandom(Enumerable.Range(1,10));
            for (int i = 0; i < 10; i++)
            {
                Console.Write("{0} ",u.Next());
            }
        }
    }

    class UniqueRandom
    {
        private readonly List<int> _currentList;
        private readonly Random _random = new Random();

        public UniqueRandom(IEnumerable<int> seed)
        {
            _currentList = new List<int>(seed);
        }

        public int Next()
        {
            if (_currentList.Count == 0)
            {
                throw new ApplicationException("No more numbers");
            }

            int i = _random.Next(_currentList.Count);
            int result = _currentList[i];
            _currentList.RemoveAt(i);
            return result;
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
名称空间SO14473321
{
班级计划
{
静态void Main（）
{
UniqueRandom u=新的UniqueRandom（可枚举范围（1,10））；
对于（int i=0；i<10；i++）
{
Write（“{0}”，u.Next（））；
}
}
}
类UniqueRandom
{
私有只读列表_currentList；
private readonly Random_Random=new Random（）；
公共UniqueRandom（IEnumerable种子）
{
_currentList=新列表（种子）；
}
公共int Next（）
{
如果（_currentList.Count==0）
{
抛出新的ApplicationException（“不再有数字”）；
}
int i=_random.Next（_currentList.Count）；
int result=_currentList[i]；
_currentList.RemoveAt（i）；
返回结果；
}
}
}
我正在发布一个洗牌算法的正确实现，因为这里发布的另一个算法不会产生统一的洗牌

正如另一个答案所述，对于要随机化的少量值，您可以简单地用这些值填充数组，洗牌数组，然后使用所需的任意数量的值

下面是（也称为Knuth Shuffle）的一个实现。（阅读该链接的“实现错误”部分（搜索“每次迭代时总是从整个有效数组索引范围中选择j”），以查看关于此处发布的其他实现的错误的讨论。）

使用系统；
使用System.Collections.Generic；
命名空间控制台应用程序2
{
静态类程序
{
静态void Main（字符串[]参数）
{
Shuffler Shuffler=新的Shuffler（）；
列表=新列表{1,2,3,4,5,6,7,8,9}；
洗牌者。洗牌（列表）；
foreach（列表中的int值）
{
控制台写入线（值）；
}
}
}
///用于洗牌集合。
公共类洗牌者
{
///创建随机数生成器为的随机数生成器。
公众洗牌者（）
{
_rng=新随机数（）；
}
///洗牌指定的数组。
///数组元素的类型。
///要洗牌的数组。
公共无效洗牌（IList数组）
{
对于（int n=array.Count；n>1；）
{
int k=_rng.Next（n）；
--n；
温度=阵列[n]；
数组[n]=数组[k]；
数组[k]=温度；
}
}
私有系统。随机；
}
}
您也可以使用存储每个随机值的数据表，然后只需执行随机方法即可！=数据列中的值请注意，我不建议这样：）。
这里还有一个“oneliner”：

试试这个：

private void NewNumber()
  {
     Random a = new Random(Guid.newGuid().GetHashCode());
     MyNumber = a.Next(0, 10);
  }

一些解释：

Guid
：：表示全局唯一标识符（Guid）

Guid.newGuid（）
生成一个唯一标识符，如“936DA01F-9ABD-4d9d-80C7-02AF85C822A8”

它在整个宇宙中都是独一无二的

哈希代码根据唯一标识符生成唯一整数

因此

Guid.newGuid（）.GetHashCode（）

为我们提供了一个唯一的数字，随机类将产生真正的随机数

样本：

使用此方法生成十个随机数，结果为：

-1541116401
7
-1936409663
3
-804754459
8
1403945863
3
1287118327
1
2112146189
1
1461188435
9
-752742620
4
-175247185
4
1666734552
7

---

我们得到了两个相邻的

1

s，但是散列码不一样。

这里是我使用散列集查找N个随机唯一数的版本。 看起来很简单，因为HashSet只能包含不同的项。 这很有趣-它会比使用列表或洗牌更快吗

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class RnDHash
    {
        static void Main()
        {
            HashSet<int> rndIndexes = new HashSet<int>();
            Random rng = new Random();
            int maxNumber;
            Console.Write("Please input Max number: ");
            maxNumber = int.Parse(Console.ReadLine());
            int iter = 0;
            while (rndIndexes.Count != maxNumber)
            {
                int index = rng.Next(maxNumber);
                rndIndexes.Add(index);
                iter++;
            }
            Console.WriteLine("Random numbers were found in {0} iterations: ", iter);
            foreach (int num in rndIndexes)
            {
                Console.WriteLine(num);
            }
            Console.ReadKey();
        }
    }
}

使用系统；
使用System.Collections.Generic；
命名空间控制台
-1541116401
7
-1936409663
3
-804754459
8
1403945863
3
1287118327
1
2112146189
1
1461188435
9
-752742620
4
-175247185
4
1666734552
7

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class RnDHash
    {
        static void Main()
        {
            HashSet<int> rndIndexes = new HashSet<int>();
            Random rng = new Random();
            int maxNumber;
            Console.Write("Please input Max number: ");
            maxNumber = int.Parse(Console.ReadLine());
            int iter = 0;
            while (rndIndexes.Count != maxNumber)
            {
                int index = rng.Next(maxNumber);
                rndIndexes.Add(index);
                iter++;
            }
            Console.WriteLine("Random numbers were found in {0} iterations: ", iter);
            foreach (int num in rndIndexes)
            {
                Console.WriteLine(num);
            }
            Console.ReadKey();
        }
    }
}

Random ran = new Random();
int randomno = ran.Next(0,100);

public static int[] getUniqueRandomArray(int min, int max, int count) {
    int[] result = new int[count];
    List<int> numbersInOrder = new List<int>();
    for (var x = min; x < max; x++) {
        numbersInOrder.Add(x);
    }
    for (var x = 0; x < count; x++) {
        var randomIndex = UnityEngine.Random.Range(0, numbersInOrder.Count);
        result[x] = numbersInOrder[randomIndex];
        numbersInOrder.RemoveAt(randomIndex);
    }

    return result;
}

  bool check[] = new bool[100001];
  Random r = new Random();
  public int randomNumber() {
      int num = r.Next(0,100000);
       while(check[num] == true) {
             num = r.Next(0,100000);
     }
    check[num] = true;
   return num;
 }

  public List<int> random_generator(){

  Random random = new Random();

   List<int> random_container = new List<int>;

     do{

       int random_number = random.next(10);

      if(!random_container.contains(random_number){

       random_container.add(random_number)
  }
}
   while(random_container.count!=10);


     return random_container; 
  }

            List<int> genered = new List<int>();

            Random rnd = new Random();

            for(int x = 0; x < files.Length; x++)
            {
                int value = rnd.Next(0, files.Length - 1);
                while (genered.Contains(value))
                {
                    value = rnd.Next(0, files.Length - 1);
                }
                genered.Add(value);

                returnFiles[x] = files[value];
            }

using System;
using System.Linq;

namespace Shuffle
{
    class Program
    {
        static Random rnd = new Random();
        static void Main(string[] args)
        {
            var alphabet = new string[] { "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" };
            Console.WriteLine("Alphabet : {0}", string.Join(",", alphabet)); 
            for (int i = 0; i < 5; i++)
            {
                var shuffledAlphabet = GetShuffledAlphabet(alphabet);
                Console.WriteLine("SHUFFLE {0}: {1}", i, string.Join(",", shuffledAlphabet));
            }
        }

        static string[] GetShuffledAlphabet(string[] arr)
        {
            int?[] uniqueNumbers = new int?[arr.Length];
            string[] shuffledAlphabet = new string[arr.Length];

            for (int i = 0; i < arr.Length; i++)
            {
                int uniqueNumber = GenerateUniqueNumber(uniqueNumberArrays);
                uniqueNumberArrays[i] = uniqueNumber;
                newArray[i] = arr[uniqueNumber];
            }

            return shuffledAlphabet;
        }

        static int GenerateUniqueNumber(int?[] uniqueNumbers)
        {
            int number = rnd.Next(uniqueNumbers.Length);

            if (!uniqueNumbers.Any(r => r == number))
            {
                return number;
            }

            return GenerateUniqueNumber(uniqueNumbers);
        }
    }
}

      int sum = 0;
        int[] hue = new int[10];
        for (int i = 0; i < 10; i++)
        {

            int m;
            do
            {
                m = rand.Next(0, 10);
            } while (hue.Contains(m) && sum != 45);
            if (!hue.Contains(m))
            {
                hue[i] = m;
                sum = sum + m;
            }

        }

List<int> randomList = new List<int>();
int UniqueRandomInt(int min, int max)
{
    var rand = new Random();
    int myNumber;
    do
    {
       myNumber = rand.Next(min, max);
    } while (randomList.Contains(myNumber));
    return myNumber;
}