Comment puis-je mélanger efficacement une liste générique en C #?

La méthode de mélange efficace de la liste générique des génériques

Dans divers scénarios de programmation, l'ordre des éléments dans des listes génériques aléatoires est une opération courante. Cet article présentera la meilleure façon d'atteindre cet objectif en C #.

Fisher-Yates Shuffle Algorithme Implementation

La méthode la plus recommandée consiste à utiliser l'algorithme Shuffle Fisher-Yates, qui est un algorithme de randomisation de liste bien connu. Pour utiliser cette méthode, veuillez définir une méthode d'extension, comme indiqué ci-dessous:

<code class="language-csharp">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>

comment utiliser:

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

Utilisation de System.Security.Cryptographie pour améliorer le hasard

Bien que efficace élevée, il peut ne pas être en mesure de générer une véritable séquence aléatoire. Afin d'améliorer le hasard, la bibliothèque offre une option plus fiable:

System.Random System.Security.Cryptography Considérations de sécurité des threads

<code class="language-csharp">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)n / 256))); //确保生成的随机数在范围内
            int k = (int)(box[0] * (n / 256.0));
            T value = list[k];
            list[k] = list[n - 1];
            list[n - 1] = value;
            n--;
        }
    }
}</code>

Lors de l'utilisation de la méthode d'extension Shuffle dans des applications multi-thread, il est nécessaire d'assurer la sécurité des threads. Une solution simple consiste à créer un nouvel exemple de

:

ThreadSafeRandom La méthode d'extension mise à jour

<code class="language-csharp">public static class ThreadSafeRandom
{
    [ThreadStatic] private static Random Local;

    public static Random ThisThreadsRandom
    {
        get { return Local ?? (Local = new Random(unchecked(Environment.TickCount * 31 + Thread.CurrentThread.ManagedThreadId))); }
    }
}</code>

Intégrez la méthode de sécurité du thread à la méthode d'extension Shuffle:

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

Cette réponse révisée fournit au cacheterrererereRanPlanations, améliore la lisibilité du code (en particulier l'examph de RNGCryprovider) et répond plus efficacement aux préoccupations de sécurité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!