随机生成10,000个数字的列表

public static class Program
{
    private static Random random = new Random();

    /// <summary>
    /// Shuffles a list of generic objects randomly using the Fisher-Yates algorithm.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="list"></param>
    public static void Randomize<T>(this IList<T> list)
    {
        int size = list.Count;
        while (size > 1)
        {                
            size--;
            int index = random.Next(size + 1);
            T value = list[index];
            list[index] = list[size];
            list[size] = value;
        }
    }

    /// <summary>
    /// Asserts uniqueness of a generic list.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="list"></param>
    /// <returns></returns>
    public static bool TestUnique<T>(IList<T> list)
    {            
        return list.Distinct().Count() == list.Count();
    }

    /// <summary>
    /// Asserts that a generic list size equals an expected size.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="list"></param>
    /// <param name="count"></param>
    /// <returns></returns>
    public static bool TestCount<T>(IList<T> list, int count)
    {
        return list.Count == count;
    }

    /// <summary>
    /// Asserts that the original list is in a different order.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="original"></param>
    /// <param name="randomized"></param>
    /// <returns></returns>
    public static bool TestOrder<T>(IList<T> original, IList<T> randomized)
    {
        return original != randomized;
    }

    static void Main(string[] args)
    {
        // User starting sequence.
        Console.WriteLine("Welcome to Shuffle. This program is written to randomly shuffle a list.");
        Console.WriteLine("To test, lets shuffle some numbers. Please enter a range of integers you wish to shuffle (Example: 1 - 10000)");

        int min, max;
        bool proceed = true;
        string response;

        do
        {
            do
            {
                // Range is not valid.
                if (!proceed)
                {
                    Console.WriteLine("Invalid range. Please make sure the minimum integer is greater than the maximum integer.");
                }
                // Get the minimum range value.
                Console.Write("\nPlease enter the minimum integer: ");
                // Check if input is an integer.
                while (!int.TryParse(Console.ReadLine(), out min))
                {
                    Console.Write("Invalid input. We are only testing for integers at the moment. Please enter a valid minimum integer: ");
                }
                // Get the minimum range value.
                Console.Write("Please enter the maximum integer: ");
                // Check if input is an integer
                while (!int.TryParse(Console.ReadLine(), out max))
                {
                    Console.Write("Invalid input. We are only testing for integers at the moment. Please enter a valid maximum integer: ");
                }
                // Check if range is valid.        
                proceed = (min < max) ? true : false;
            } while (!proceed);

            Console.WriteLine("Testing shuffle for a range of {0} to {1}...\n", min, max);

            // Create a list.
            List<int> numbers = new List<int>(Enumerable.Range(min, max));

            // Assert list size.
            Debug.Assert(TestCount<int>(numbers, (max - min + 1)));

            // Assert uniqueness.
            Debug.Assert(TestUnique<int>(numbers));

    #if DEBUG
            // Copy original list of numbers only in debug mode.
            List<int> originalNumbers = new List<int>(numbers);
    #endif

            // Randomize the list.
            numbers.Randomize();

            // Re-assert uniqueness.
            Debug.Assert(TestUnique<int>(numbers));

            // Assert random order.
            Debug.Assert(TestOrder(originalNumbers, numbers));

            // Output the list.
            numbers.ForEach(num => Console.Write("[{0}], ", num));

            // User input to re-run test.
            Console.Write("\n\nWould you like to run another test? (y|n): ");

            response = Console.ReadLine();

            while(response.ToLower() != "y" && response.ToLower() != "n")
            {
                Console.Write("Invalid response. Please use 'y' or 'n'. Would you like to run another test? ");
                response = Console.ReadLine();
            }

        } while (response == "y");   

    }
}

private static List<int> CreateRandomList(int listSize)
{
    // ...
}
private static void PrintList(IList<int> lst) 
{
    // ...
}

public static void Main(string[] args) 
{
    const int listSize = 10000;
    var randomList = CreateRandomList(listSize);

    Debug.Assert(randomList.Length == listSize);
    Debug.Assert(randomList.Distinct().Count() == randomList.Count);

    PrintList(randomList);
}

void Main()
{
    const int listSize = 10000;
    var rnd = new Random();
    var randomList = Enumerable.Range(1, listSize).OrderBy(e => rnd.Next()).ToList();

    // These are not needed, we can be confident the core libraries are not broken
    Debug.Assert(randomList.Count == listSize);                      
    Debug.Assert(randomList.Distinct().Count() == randomList.Count);

    var listOutput = string.Join(", ", randomList);
    Console.WriteLine(listOutput);
}

// Get the minimum range value.
Console.Write("\nPlease enter the minimum integer: ");

// Range is not valid.
if (!proceed)

// Get the minimum range value.
Console.Write("\nPlease enter the minimum integer: ");
// Check if input is an integer.
while (!int.TryParse(Console.ReadLine(), out min))
{
    Console.Write("Invalid input. We are only testing for integers at the moment. Please enter a valid minimum integer: ");
}
// Get the minimum range value.
Console.Write("Please enter the maximum integer: ");

proceed = (min < max) ? true : false;

proceed = min < max;

Debug.Assert(numbers.Count.Equals((max - min) + 1));

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

namespace GenRandom
{
   class Program
   {
      /// <summary>
      /// This method fills a list of integers with unique random numbers based
      /// on the intDepth variable.
      /// </summary>
      /// <param name="intDepth">How many numbers to generate</param>
      /// <param name="lst_intOutput">List of integers as output</param>
      public static void GenerateNumbers(int intDepth, List<int> lst_intOutput)
      {
         Dictionary<int, bool> map_int2blnSource =
            Enumerable.Range(0, intDepth).Select(i => new KeyValuePair<int, bool>(i, false))
            .ToDictionary(k => k.Key, v => v.Value);

         Random ran = new Random();
         while (map_int2blnSource.Any(kvp => !kvp.Value))
         {
            // generate random and ensure uniqueness before returning.
            int intCurrent = ran.Next(0, intDepth);
            if (!map_int2blnSource[intCurrent])
            {
               lst_intOutput.Add((intCurrent + 1));
               map_int2blnSource[intCurrent] = true;
            }
         }
      }

      /// <summary>
      /// Only shown for explanation
      /// This could be any .NET compatible language calling the algorithm.
      /// </summary>
      /// <param name="args">First/only param is the high number.</param>
      static void Main(string[] args)
      {
         int intDepth = 0;
         if (!int.TryParse(args.FirstOrDefault(), out intDepth))
         {
            Console.WriteLine("GenRandom n\r\nwhere n is the top number.");
            return;
         }

         Console.WriteLine("Generating...");
         List<int> lst_intResult = new List<int>(intDepth);
         GenerateNumbers(intDepth, lst_intResult);

         Console.WriteLine(string.Join(Environment.NewLine, lst_intResult));
      }
   }
}

#include <iostream>
#include <unordered_set>

int main()
{
    const size_t min = 1;
    const size_t max = 10000;

    std::unordered_set<size_t> set;

    while (set.size() < 10000)
    {
        set.emplace(min + (rand() % static_cast<int>(max - min + 1)));
    }
}

private static Random randFY = new Random();
public static void FisherYatesShuffle(ref List<int> Deck)
{
    //FishYate in place shuffle
    int swap;
    int temp;
    for (int i = Deck.Count - 1; i > 0; i--)
    {
        swap = randFY.Next(i + 1);  //.net rand is not inclusive
        if (swap != i)
        {
            temp = Deck[i];
            Deck[i] = Deck[swap];
            Deck[swap] = temp;
        }
    }
}