Angka Acak di C#: Random.Next, Rentang, Seed, Shuffle dan Random yang Aman

Class System.Random menghasilkan angka pseudo-random: urutan deterministik yang terlihat acak, dimulai dari sebuah seed. Buat satu instance lalu panggil method-nya:

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"));
    }
}

Contoh output:

1294270287
83
You rolled a 5
0.6060

Jalankan lagi dan angkanya berubah. Batas atasnya eksklusif: Next(1, 7) bisa mengembalikan 1, 2, 3, 4, 5, atau 6, tetapi tidak pernah 7. Untuk angka antara 1 dan 10 (10 termasuk), tulis Next(1, 11). Memberikan max yang lebih kecil dari min akan melempar ArgumentOutOfRangeException.

Angka acak dalam rentang tertentu

Next(min, max) dipakai untuk bilangan bulat. Untuk double dalam suatu rentang, skalakan NextDouble(); untuk decimal seperti harga, bangun dari bilangan bulat agar hasilnya punya presisi yang kamu inginkan:

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);
    }
}

Contoh output:

23.6 C
72.42
heads
N
-3

rng.Next(100, 10000) / 100m memilih jumlah sen dalam bilangan bulat lalu membaginya dengan decimal, jadi harganya selalu punya tepat dua angka desimal. Menskalakan double akan menghasilkan nilai seperti 72.4183.

Seed: urutan yang bisa diulang

Memberikan seed berupa bilangan bulat membuat urutannya bisa diulang. Dua object Random dengan seed yang sama menghasilkan angka yang persis sama, dengan urutan yang sama:

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));
    }
}

Output:

16 29 91 99 91
16 29 91 99 91
38

Seed adalah yang kamu butuhkan untuk tes, simulasi yang perlu dijalankan ulang, replay di game, dan level yang dibuat secara prosedural ("world seed 2026"). Catat seed yang kamu pakai, maka hasil yang mengejutkan bisa direproduksi nanti.

Microsoft tidak menjamin sebuah seed menghasilkan urutan yang sama di setiap versi .NET. Jangan menyimpan hasil dari seed sebagai data (misalnya membuat ID pelanggan dari seed tetap lalu berharap bisa membuatnya ulang setelah upgrade).

Memilih elemen acak

Indeks acak adalah Next(0, count), yang selalu menjadi indeks valid karena batas atasnya eksklusif:

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]}");
        }
    }
}

Output:

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

Undian berbobot memetakan angka dari 0 sampai 99 ke rentang yang ukurannya sama dengan bobotnya: 0 sampai 69 adalah common, 70 sampai 94 rare, dan 95 sampai 99 legendary. Dari 1.000 kali undian, hasilnya mendekati 700, 250, dan 50 (di sini 695, 260, dan 45).

Mengacak list: Fisher-Yates

Untuk menyusun list dalam urutan acak, telusuri dari ujung lalu tukar setiap elemen dengan elemen acak di posisinya atau sebelumnya. Inilah shuffle Fisher-Yates; caranya cepat dan setiap urutan punya peluang yang sama. Jika ditulis sebagai method generic, cara ini bisa dipakai untuk array dan list dengan tipe elemen apa pun:

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));
    }
}

Output:

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

Dua jalan pintas yang sering kamu lihat di internet lebih buruk. list.OrderBy(x => rng.Next()) memang berjalan, tetapi melakukan sorting, jadi lebih lambat, dan key acaknya bisa bertabrakan. Menukar dengan rng.Next(items.Count) alih-alih rng.Next(i + 1) terlihat mirip, tetapi membuat beberapa urutan lebih mungkin muncul daripada yang lain. Di .NET 8 dan sesudahnya, Random.Shared.Shuffle(array) melakukan shuffle yang benar langsung di array itu, dan rng.GetItems(choices, 5) memilih lima item acak (boleh berulang).

Jebakan new Random() di dalam perulangan

Bug klasik adalah membuat Random baru setiap kali butuh angka:

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

Di .NET Framework, new Random() tanpa seed memakai jam sistem (Environment.TickCount), yang hanya berubah setiap 10 sampai 16 milidetik. Panggilan dalam perulangan cepat membuat instance dengan seed yang sama dan mengembalikan angka yang sama, jadi perulangan lemparan dadu mencetak 4 4 4 4 4. .NET Core dan .NET 5+ memberi seed ke setiap instance dari sumber acak bersama, yang menyembunyikan gejalanya, tetapi membuat satu object untuk setiap angka tetap boros, dan kodenya rusak saat dipakai ulang di proyek lama atau di Unity.

Solusinya adalah satu instance untuk class itu, disimpan di sebuah field:

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));
    }
}

Output:

3 6 6 5 6 1 2 1

Seed di sini hanya agar contohnya mencetak hal yang sama setiap kali dijalankan; di game sungguhan kamu akan menulis new Random().

Thread dan Random.Shared

Random tidak thread-safe. Jika dua thread memanggil Next pada instance yang sama secara bersamaan, state internalnya bisa rusak; gejala yang terkenal adalah instance yang sejak itu selalu mengembalikan 0. Pilihannya, dari yang paling sederhana:

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 adalah pilihan default yang tepat di kode baru: thread-safe, tidak butuh field, dan diberi seed secara acak. Ia tidak bisa diberi seed, jadi pakai new Random(seed) milikmu sendiri saat kamu butuh hasil yang bisa diulang.

Angka acak yang aman secara kriptografis

System.Random memang dirancang bisa ditebak. Siapa pun yang tahu seed-nya, atau melihat cukup banyak output-nya, bisa menghitung sisanya. Itu tidak masalah untuk game dan sampling, tetapi salah untuk password, token reset, ID sesi, key, dan undian lotre. Untuk semua itu, pakai RandomNumberGenerator dari System.Security.Cryptography, yang membaca dari generator aman milik sistem operasi:

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}");
    }
}

Contoh output:

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

RandomNumberGenerator.GetInt32 (tersedia di .NET Core 3.0 dan sesudahnya) mengembalikan bilangan bulat tanpa bias di dalam rentangnya. Jangan membuat kode keamanan dengan bytes[0] % 10: operasi modulo membuat beberapa digit lebih mungkin muncul daripada yang lain. Di .NET 6 dan sesudahnya, RandomNumberGenerator.GetBytes(16) langsung mengembalikan array baru, dan Convert.ToHexString(bytes) memformatnya. Untuk ID unik yang tidak perlu dirahasiakan, Guid.NewGuid() lebih sederhana.