Comment puis-je mélanger une liste générique au hasard en C # efficacement et en toute sécurité?

Le tri aléatoire de la liste générique des génériques

Le tri aléatoire des listes génériques (telles que les listes numériques) est une tâche courante dans la programmation. En C #, il existe plusieurs méthodes qui peuvent utiliser la méthode construite -in, la méthode d'extension et même les bibliothèques de troisième partie pour atteindre cet objectif. Il est essentiel de comprendre les meilleures méthodes et limites pour obtenir les meilleures performances et exactités.

Fisher-Yates Shuffle Expansion Method

L'une des méthodes les plus couramment utilisées est d'utiliser Fisher-Yates pour mélanger l'algorithme. Cette méthode perturbe au hasard l'élément d'Ilist

en répétant les éléments avec des index aléatoires. Le bloc de code suivant démontre une méthode d'extension pour implémenter l'algorithme Fisher-Yates:

<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>

Pour utiliser cette méthode d'extension, appelez simplement le shuffle () pour iList

. Par exemple:

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

Utiliser System.Security.Cryptographie pour améliorer le hasard

Bien que le system.Random soit pratique, il ne fournit pas toujours suffisamment de hasard. Si vous avez besoin d'une aléatoire de qualité plus élevée, System.Security.Cryptography Library fournit un générateur de nombres aléatoires plus sûr:

<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>

L'importance des considérations de performance et de la sécurité des threads

La classe System.Random utilisée dans le premier exemple n'est pas du thread -afe. Cela signifie que si plusieurs threads essaient d'accéder à la même instance System.Random en même temps, des résultats incorrects peuvent se produire. Pour résoudre ce problème, la classe ThreadsaFrandom fournit une solution de sécurité de thread en utilisant un générateur de nombres aléatoires local. La méthode d'extension Shuffle () modifiée du threadsaferantom pour assurer l'exactitude dans l'environnement multi-thread.

Conclusion

Dans les listes génériques aléatoires, les développeurs peuvent choisir entre utiliser System.Random (pour la commodité) ou System.Security.Cryptography (pour un meilleur aléatoire) Fisher-yates Méthodes de mélange. De plus, la classe Threadsaferandom permet de garantir la sécurité des threads dans des applications multi-thread. La méthode spécifique dépend des considérations de hasard et de performance requises.

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!