Bagaimanakah saya boleh mengosongkan senarai generik secara rawak di C# dengan cekap dan selamat?

Penyortiran rawak senarai generik generik

Penyortiran rawak senarai generik (seperti senarai digital) adalah tugas yang sama dalam pengaturcaraan. Dalam C#, terdapat pelbagai kaedah yang boleh menggunakan kaedah terbina, kaedah lanjutan, dan juga perpustakaan pihak ketiga untuk mencapai tujuan ini. Memahami kaedah dan batasan terbaik adalah penting untuk mendapatkan prestasi terbaik dan ketepatan.

kaedah pengembangan shuffle fisher-yates

Salah satu kaedah yang paling biasa digunakan ialah menggunakan algoritma fisher-yates untuk shuffle. Kaedah ini secara rawak mengganggu elemen ilist

dengan mengulangi unsur -unsur dengan indeks rawak. Blok kod berikut menunjukkan kaedah lanjutan untuk melaksanakan algoritma 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>

Untuk menggunakan kaedah pengembangan ini, hubungi shuffle () untuk ilist

. Contohnya:

Gunakan System.Security.Cryptography untuk meningkatkan rawak

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

Walaupun System.Random adalah mudah, ia tidak selalu memberikan rawak yang cukup. Sekiranya anda memerlukan rawak yang lebih tinggi, sistem.security.cryptography Perpustakaan menyediakan penjana nombor rawak yang lebih selamat:

kepentingan pertimbangan prestasi dan keselamatan benang

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

Kelas System.Random yang digunakan dalam contoh pertama bukan thread -safe. Ini bermakna jika beberapa benang cuba mengakses sistem yang sama. Untuk menyelesaikan masalah ini, kelas ThreadSafrandom menyediakan penyelesaian keselamatan thread dengan menggunakan penjana nombor rawak tempatan. Kaedah pengembangan shuffle () yang diubahsuai dari threadsaferantom untuk memastikan ketepatan dalam persekitaran multi -threaded.

Kesimpulan

Dalam senarai generik secara rawak, pemaju boleh memilih antara menggunakan System.Random (untuk kemudahan) atau System.Security.Cryptography (untuk rawak yang lebih baik) kaedah shuffling fisher-yates. Di samping itu, kelas Threadsaferandom membantu memastikan keselamatan benang dalam aplikasi multi -threaded. Kaedah khusus bergantung kepada pertimbangan rawak dan prestasi yang diperlukan.

Atas ialah kandungan terperinci Bagaimanakah saya boleh mengosongkan senarai generik secara rawak di C# dengan cekap dan selamat?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!