C# Random: מספרים אקראיים, טווחים, Seed, ערבוב ואקראיות מאובטחת

המחלקה System.Random יוצרת מספרים פסאודו-אקראיים: רצף דטרמיניסטי שנראה אקראי ומתחיל מ-seed. צרו מופע אחד וקראו למתודות שלו:

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.

Seed: רצפים שחוזרים על עצמם

העברה של seed מספרי הופכת את הרצף לחוזר. שני אובייקטי Random עם אותו seed מפיקים בדיוק את אותם מספרים, באותו סדר:

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

seed הוא מה שצריך לבדיקות, לסימולציות שצריך להריץ שוב, להילוך חוזר במשחקים ולשלבים שנוצרים פרוצדורלית ("world seed 2026"). תעדו בלוג את ה-seed שהשתמשתם בו, וכך אפשר יהיה לשחזר אחר כך תוצאה מפתיעה.

Microsoft לא מבטיחה ש-seed יפיק את אותו רצף בכל גרסה של .NET. אל תשמרו פלט שנוצר מ-seed כנתונים (למשל, יצירת מזהי לקוחות מ-seed קבוע מתוך ציפייה ליצור אותם מחדש אחרי שדרוג).

בחירת איבר אקראי

אינדקס אקראי הוא 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 הוא common, 70 עד 94 הוא rare, ו-95 עד 99 הוא legendary. לאורך 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() בלי seed משתמש בשעון המערכת (Environment.TickCount), שמשתנה רק כל 10 עד 16 אלפיות שנייה. קריאות בלולאה מהירה יוצרות מופעים עם אותו seed ומחזירות אותו מספר, כך שלולאה של הטלות קובייה מדפיסה 4 4 4 4 4. .NET Core ו-.NET 5 ואילך נותנים seed לכל מופע ממקור אקראי משותף, וזה מסתיר את הסימפטום, אבל יצירת אובייקט לכל מספר עדיין בזבזנית, והקוד נשבר כשמשתמשים בו שוב בפרויקטים ישנים או ב-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

ה-seed כאן נועד רק כדי שהדוגמה תדפיס אותו דבר בכל הרצה; במשחק אמיתי הייתם כותבים 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 היא ברירת המחדל הנכונה בקוד חדש: הוא בטוח לתהליכונים, לא צריך שדה, ומקבל seed אקראי. אי אפשר לתת לו seed, אז השתמשו ב-new Random(seed) משלכם כשאתם צריכים יכולת שחזור.

מספרים אקראיים מאובטחים קריפטוגרפית

System.Random צפוי מעצם התכנון שלו. כל מי שיודע את ה-seed, או רואה מספיק פלטים, יכול לחשב את השאר. זה בסדר למשחקים ולדגימה, ושגוי לסיסמאות, טוקנים לאיפוס, מזהי סשן, מפתחות והגרלות. עבורם השתמשו ב-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() פשוט יותר.