الأرقام العشوائية في C#: Random.Next والنطاقات والبذور والخلط والعشوائية الآمنة

يولّد الصنف System.Random أرقامًا شبه عشوائية: تسلسلًا حتميًا يبدو عشوائيًا، يبدأ من بذرة. أنشئ مثيلًا واحدًا واستدعِ دواله:

using System;

class Program
{
    static void Main()
    {
        var rng = new Random();

        int any = rng.Next();              // 0 to int.MaxValue - 1
        int under100 = rng.Next(100);      // 0 to 99
        int dice = rng.Next(1, 7);         // 1 to 6
        double fraction = rng.NextDouble(); // 0.0 to just under 1.0

        Console.WriteLine(any);
        Console.WriteLine(under100);
        Console.WriteLine($"You rolled a {dice}");
        Console.WriteLine(fraction.ToString("F4"));
    }
}

مخرجات على سبيل المثال:

1294270287
83
You rolled a 5
0.6060

شغّله مرة أخرى فتتغيّر الأرقام. الحد الأعلى غير مشمول: قد تعيد Next(1, 7) القيم 1 أو 2 أو 3 أو 4 أو 5 أو 6، ولا تعيد 7 أبدًا. لرقم بين 1 و10 شاملًا اكتب Next(1, 11). وتمرير max أصغر من min يرمي ArgumentOutOfRangeException.

أرقام عشوائية في نطاق

تغطي Next(min, max) الأعداد الصحيحة. لقيمة double في نطاق، حجّم NextDouble()؛ ولقيمة decimal مثل السعر، ابنها من أعداد صحيحة لتحصل النتيجة على الدقة التي تريدها:

using System;

class Program
{
    static void Main()
    {
        var rng = new Random();

        double temperature = 15.0 + rng.NextDouble() * (30.0 - 15.0);  // 15.0 to 30.0
        decimal price = rng.Next(100, 10000) / 100m;                    // 1.00 to 99.99
        bool coinFlip = rng.Next(2) == 0;
        char letter = (char)('A' + rng.Next(26));
        int negative = rng.Next(-10, 11);                              // -10 to 10

        Console.WriteLine($"{temperature:F1} C");
        Console.WriteLine(price);
        Console.WriteLine(coinFlip ? "heads" : "tails");
        Console.WriteLine(letter);
        Console.WriteLine(negative);
    }
}

مخرجات على سبيل المثال:

23.6 C
72.42
heads
N
-3

تختار rng.Next(100, 10000) / 100m عددًا صحيحًا من السنتات وتقسمه على decimal، فيكون للسعر دائمًا منزلتان عشريتان بالضبط. أما تحجيم double فسيعطي قيمًا مثل 72.4183.

البذور: تسلسلات قابلة للتكرار

تمرير بذرة صحيحة يجعل التسلسل قابلًا للتكرار. كائنا Random بالبذرة نفسها ينتجان الأرقام نفسها تمامًا، بالترتيب نفسه:

using System;

class Program
{
    static void Main()
    {
        var a = new Random(2026);
        var b = new Random(2026);

        var fromA = new int[5];
        var fromB = new int[5];
        for (int i = 0; i < 5; i++)
        {
            fromA[i] = a.Next(1, 100);
            fromB[i] = b.Next(1, 100);
        }
        Console.WriteLine(string.Join(" ", fromA));
        Console.WriteLine(string.Join(" ", fromB));

        var c = new Random(7);
        Console.WriteLine(c.Next(1, 100));
    }
}

المخرجات:

16 29 91 99 91
16 29 91 99 91
38

البذور هي ما تريده للاختبارات، والمحاكاة التي تحتاج إلى إعادة تشغيلها، وإعادة العرض في الألعاب، والمراحل المولّدة إجرائيًا ("world seed 2026"). سجّل البذرة التي استخدمتها، فيمكن إعادة إنتاج أي نتيجة مفاجئة لاحقًا.

لا تعد Microsoft بأن البذرة تنتج التسلسل نفسه في كل إصدار من .NET. لا تحفظ المخرجات المبذورة كبيانات (مثلًا توليد معرّفات العملاء من بذرة ثابتة وتوقّع إعادة توليدها بعد ترقية).

اختيار عنصر عشوائي

الفهرس العشوائي هو Next(0, count)، وهو فهرس صالح دائمًا لأن الحد الأعلى غير مشمول:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var rng = new Random(11);
        var prizes = new List<string> { "mug", "t-shirt", "sticker pack", "gift card", "hoodie" };

        for (int i = 0; i < 3; i++)
        {
            string prize = prizes[rng.Next(prizes.Count)];
            Console.WriteLine($"Winner {i + 1} gets a {prize}");
        }

        // Weighted choice: common 70%, rare 25%, legendary 5%
        string[] tiers = { "common", "rare", "legendary" };
        int[] weights = { 70, 25, 5 };
        var counts = new int[3];
        for (int draw = 0; draw < 1000; draw++)
        {
            int roll = rng.Next(100);   // 0..99
            int tier = roll < weights[0] ? 0 : roll < weights[0] + weights[1] ? 1 : 2;
            counts[tier]++;
        }
        for (int t = 0; t < tiers.Length; t++)
        {
            Console.WriteLine($"{tiers[t],-10} {counts[t]}");
        }
    }
}

المخرجات:

Winner 1 gets a sticker pack
Winner 2 gets a mug
Winner 3 gets a sticker pack
common     695
rare       260
legendary  45

يربط السحب الموزون رقمًا من 0 إلى 99 بنطاقات أحجامها هي الأوزان: من 0 إلى 69 شائع، ومن 70 إلى 94 نادر، ومن 95 إلى 99 أسطوري. عبر 1,000 سحبة تقترب الأعداد من 700 و250 و50 (هنا 695 و260 و45).

خلط قائمة: Fisher-Yates

لوضع قائمة بترتيب عشوائي، امشِ من النهاية وبدّل كل عنصر مع عنصر عشوائي في موضعه أو قبله. هذا خلط Fisher-Yates؛ سريع وكل ترتيب فيه متساوي الاحتمال. ومكتوبًا كدالة عامة يعمل مع المصفوفات والقوائم بأي نوع عناصر:

using System;
using System.Collections.Generic;

class Program
{
    static void Shuffle<T>(IList<T> items, Random rng)
    {
        for (int i = items.Count - 1; i > 0; i--)
        {
            int j = rng.Next(i + 1);         // 0..i inclusive
            T tmp = items[i];
            items[i] = items[j];
            items[j] = tmp;
        }
    }

    static void Main()
    {
        var rng = new Random(5);
        var cards = new List<string> { "A", "2", "3", "4", "5", "6", "7", "8" };
        Shuffle(cards, rng);
        Console.WriteLine(string.Join(" ", cards));

        int[] quiz = { 1, 2, 3, 4, 5 };
        Shuffle(quiz, rng);                  // arrays implement IList<T>
        Console.WriteLine(string.Join(" ", quiz));
    }
}

المخرجات:

5 A 8 6 4 7 2 3
4 2 1 3 5

اختصاران ستراهما على الإنترنت أسوأ. list.OrderBy(x => rng.Next()) يعمل لكنه يفرز، فهو أبطأ، وقد تتصادم المفاتيح العشوائية. والتبديل بـ rng.Next(items.Count) بدل rng.Next(i + 1) يبدو مشابهًا لكنه يجعل بعض الترتيبات أكثر احتمالًا من غيرها. في .NET 8 وما بعده تنفّذ Random.Shared.Shuffle(array) خلطًا صحيحًا في المكان، وتختار rng.GetItems(choices, 5) خمسة عناصر عشوائية (مع التكرار).

فخ new Random() داخل حلقة

خطأ تقليدي هو إنشاء Random جديد كلما احتجت إلى رقم:

// Don't do this
int RollDie()
{
    var rng = new Random();   // new instance on every call
    return rng.Next(1, 7);
}

في .NET Framework تستخدم new Random() دون بذرة ساعة النظام (Environment.TickCount)، التي لا تتغيّر إلا كل 10 إلى 16 ميلي ثانية. الاستدعاءات في حلقة سريعة تنشئ مثيلات بالبذرة نفسها وتعيد الرقم نفسه، فتطبع حلقة رمي النرد 4 4 4 4 4. تبذر .NET Core و.NET 5+ كل مثيل من مصدر عشوائي مشترك، وهذا يخفي العرض، لكن إنشاء كائن لكل رقم ما زال هدرًا، وتنكسر الشيفرة حين يُعاد استخدامها في مشاريع أقدم أو في Unity.

الحل مثيل واحد للصنف، مخزّن في حقل:

using System;

class Dice
{
    private static readonly Random Rng = new Random(99);   // one instance, reused

    public static int Roll() => Rng.Next(1, 7);
}

class Program
{
    static void Main()
    {
        var rolls = new int[8];
        for (int i = 0; i < rolls.Length; i++)
        {
            rolls[i] = Dice.Roll();
        }
        Console.WriteLine(string.Join(" ", rolls));
    }
}

المخرجات:

3 6 6 5 6 1 2 1

البذرة هنا فقط كي يطبع المثال الشيء نفسه في كل تشغيل؛ في لعبة حقيقية ستكتب new Random().

الخيوط وRandom.Shared

Random غير آمن مع الخيوط. إن استدعى خيطان Next على المثيل نفسه في الوقت نفسه فقد تفسد حالته الداخلية؛ والعرض المعروف مثيل يعيد 0 من تلك اللحظة فصاعدًا. الخيارات، بدءًا بالأبسط:

static class Dice
{
    // .NET 6 and later: a thread-safe shared instance
    public static int RollShared() => Random.Shared.Next(1, 7);

    // Any version: one instance per thread
    [ThreadStatic] private static Random _local;
    private static Random Local => _local ?? (_local = new Random(Guid.NewGuid().GetHashCode()));
    public static int RollPerThread() => Local.Next(1, 7);

    // Any version: a lock around one shared instance
    private static readonly Random _rng = new Random();
    private static readonly object _sync = new object();
    public static int RollLocked()
    {
        lock (_sync) { return _rng.Next(1, 7); }
    }
}

Random.Shared هو الافتراضي الصحيح في الشيفرة الجديدة: آمن مع الخيوط، ولا يحتاج إلى حقل، ومبذور عشوائيًا. لا يمكن بذره، فاستخدم new Random(seed) خاصًا بك حين تحتاج إلى قابلية التكرار.

الأرقام العشوائية الآمنة تشفيريًا

System.Random قابل للتنبؤ بتصميمه. من يعرف البذرة، أو يرى مخرجات كافية، يستطيع حساب البقية. هذا مقبول للألعاب وأخذ العينات، وخطأ لكلمات المرور ورموز إعادة التعيين ومعرّفات الجلسات والمفاتيح وسحوبات اليانصيب. لهذه استخدم RandomNumberGenerator من System.Security.Cryptography، الذي يقرأ من المولّد الآمن لنظام التشغيل:

using System;
using System.Security.Cryptography;
using System.Text;

class Program
{
    static void Main()
    {
        int code = RandomNumberGenerator.GetInt32(100000, 1000000);  // 6-digit code
        Console.WriteLine($"Verification code: {code}");

        var bytes = new byte[16];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(bytes);
        }
        string token = BitConverter.ToString(bytes).Replace("-", "").ToLowerInvariant();
        Console.WriteLine($"Reset token: {token}");

        const string alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789";
        var password = new StringBuilder();
        for (int i = 0; i < 12; i++)
        {
            password.Append(alphabet[RandomNumberGenerator.GetInt32(alphabet.Length)]);
        }
        Console.WriteLine($"Password: {password}");
    }
}

مخرجات على سبيل المثال:

Verification code: 276062
Reset token: 391e40ab5fa205e6457e48661586d10a
Password: gyv8LWyajJcF

تعيد RandomNumberGenerator.GetInt32 (المتاحة في .NET Core 3.0 وما بعده) عددًا صحيحًا غير منحاز في النطاق. لا تبنِ رموزًا آمنة بـ bytes[0] % 10: فباقي القسمة يجعل بعض الأرقام أكثر احتمالًا من غيرها. في .NET 6 وما بعده تعيد RandomNumberGenerator.GetBytes(16) مصفوفة جديدة مباشرة، وتنسّقها Convert.ToHexString(bytes). وللمعرّفات الفريدة التي لا تهمّ سريتها تكون Guid.NewGuid() أبسط.