How Can I Randomly Shuffle a Generic List in C# Efficiently and Safely?

The random sorting of the generic list of generics

Random sorting of generic lists (such as digital lists) is a common task in programming. In C#, there are multiple methods that can use the built -in method, extension method, and even third -party libraries to achieve this purpose. Understanding the best methods and limitations is essential for gaining the best performance and correctness.

Fisher-Yates shuffle expansion method

One of the most commonly used methods is to use Fisher-Yates to shuffle algorithm. This method randomly disrupts the element of iList

by repeating the elements with random indexes. The following code block demonstrates an extension method to implement the Fisher-Yates algorithm:

<code class="language-csharp">private static Random rng = new Random();

public static void Shuffle<T>(this IList<T> list)
{
    int n = list.Count;
    while (n > 1)
    {
        n--;
        int k = rng.Next(n + 1);
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
    }
}</code>

To use this expansion method, just call the shuffle () for iList

. For example:

<code class="language-csharp">List<Product> products = GetProducts();
products.Shuffle();</code>

Use System.Security.Cryptography to improve randomness

Although System.random is convenient, it does not always provide enough randomness. If you need higher -quality randomness, System.Security.Cryptography Library provides a safer random number generator:

<code class="language-csharp">using System.Security.Cryptography;
...
public static void Shuffle<T>(this IList<T> list)
{
    using (RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider())
    {
        int n = list.Count;
        while (n > 1)
        {
            byte[] box = new byte[1];
            do provider.GetBytes(box);
            while (!(box[0] < (byte)((double)uint.MaxValue / uint.MaxValue * n)));
            int k = (int)(box[0] % n);
            T value = list[k];
            list[k] = list[n - 1];
            list[n - 1] = value;
        }
    }
}</code>

The importance of performance considerations and thread security

The SYSTEM.RANDOM class used in the first example is not thread -safe. This means that if multiple threads try to access the same system.random instance at the same time, incorrect results may occur. To solve this problem, the ThreadSAFRANDOM class provides a thread security solution by using a local random number generator. The modified SHuffle () expansion method of the Threadsaferantom to ensure the correctness in the multi -threaded environment.

Conclusion

In random generic lists, developers can choose between using System.RANDOM (for convenience) or System.Security.Cryptography (for better randomness) Fisher-Yates shuffling methods. In addition, the ThreadsafeRANDOM class helps ensure that thread security in multi -threaded applications. The specific method depends on the required randomness and performance considerations.

The above is the detailed content of How Can I Randomly Shuffle a Generic List in C# Efficiently and Safely?. For more information, please follow other related articles on the PHP Chinese website!