Dokumentacja C# z przykładami: Liczby losowe

Q: Jak wylosować liczbę w C#?

Utwórz jeden obiekt Random i wywołaj Next: var rng = new Random(); int roll = rng.Next(1, 7); daje od 1 do 6. Next(max) daje od 0 do max - 1, a NextDouble() daje double od 0.0 do 1.0, bez 1.0. W .NET 6 i nowszych możesz pominąć obiekt i użyć Random.Shared.Next(1, 7).

Q: Czy górna granica Random.Next jest włączona?

Nie. Next(min, max) zwraca liczbę większą lub równą min i ściśle mniejszą od max. Dla liczby od 1 do 10 włącznie napisz Next(1, 11). Dzięki temu Next(0, list.Count) jest zawsze poprawnym indeksem listy.

Q: Dlaczego new Random() daje te same liczby?

W .NET Framework new Random() bierze ziarno z zegara systemowego, który zmienia się tylko co kilka milisekund, więc kilka instancji utworzonych w szybkiej pętli dostaje to samo ziarno i ten sam ciąg. .NET Core i .NET 5+ dają każdej instancji inne ziarno, ale rozwiązanie jest wszędzie takie samo: utwórz jeden Random i używaj go wielokrotnie.

Q: Jak za każdym razem dostać te same liczby losowe w C#?

Przekaż ziarno do konstruktora: new Random(42). Dwie instancje z tym samym ziarnem dają ten sam ciąg, dzięki czemu testy, symulacje i generowanie proceduralne są powtarzalne. Ciąg dla danego ziarna może różnić się między wersjami .NET, więc nie zapisuj wyników z ziarnem jako trwałych danych.

Q: Czy System.Random jest wystarczająco bezpieczny do haseł lub tokenów?

Nie. Random jest przewidywalny: każdy, kto pozna jego stan lub ziarno, może odtworzyć liczby. Do haseł, tokenów, kluczy i wszystkiego, co związane z bezpieczeństwem, używaj System.Security.Cryptography.RandomNumberGenerator, na przykład RandomNumberGenerator.GetInt32(0, 10) albo RandomNumberGenerator.GetBytes(32).

Klasa System.Random generuje liczby pseudolosowe: deterministyczny ciąg, który wygląda na losowy i zaczyna się od ziarna (seed). Utwórz jedną instancję i wywołuj jej metody:

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

Przykładowy wynik:

1294270287
83
You rolled a 5
0.6060

Uruchom ponownie, a liczby się zmienią. Górna granica jest wyłączona: Next(1, 7) może zwrócić 1, 2, 3, 4, 5 lub 6, ale nigdy 7. Dla liczby od 1 do 10 włącznie napisz Next(1, 11). Przekazanie max mniejszego niż min rzuca ArgumentOutOfRangeException.

Liczby losowe w zakresie

Next(min, max) obsługuje liczby całkowite. Dla double w zakresie przeskaluj NextDouble(); dla decimal, na przykład ceny, zbuduj wartość z liczb całkowitych, żeby wynik miał pożądaną precyzję:

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

Przykładowy wynik:

23.6 C
72.42
heads
N
-3

rng.Next(100, 10000) / 100m losuje całkowitą liczbę centów i dzieli przez decimal, więc cena ma zawsze dokładnie dwa miejsca po przecinku. Skalowanie double dałoby wartości w rodzaju 72.4183.

Ziarno: powtarzalne ciągi

Przekazanie ziarna w postaci liczby całkowitej sprawia, że ciąg jest powtarzalny. Dwa obiekty Random z tym samym ziarnem dają dokładnie te same liczby w tej samej kolejności:

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

Wynik:

16 29 91 99 91
16 29 91 99 91
38

Ziarna przydają się w testach, symulacjach, które trzeba powtórzyć, powtórkach w grach i proceduralnie generowanych poziomach ("ziarno świata 2026"). Zapisuj w logach użyte ziarno, a zaskakujący wynik da się później odtworzyć.

Microsoft nie obiecuje, że ziarno da ten sam ciąg w każdej wersji .NET. Nie zapisuj wyników z ziarnem jako danych (na przykład generując identyfikatory klientów ze stałego ziarna w oczekiwaniu, że po aktualizacji da się je wygenerować ponownie).

Losowanie elementu

Losowy indeks to Next(0, count), który zawsze jest poprawnym indeksem, bo górna granica jest wyłączona:

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

Wynik:

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

Losowanie z wagami odwzorowuje liczbę od 0 do 99 na przedziały, których rozmiary są wagami: od 0 do 69 to common, od 70 do 94 rare, od 95 do 99 legendary. Przy 1000 losowaniach liczniki lądują w okolicy 700, 250 i 50 (tutaj 695, 260 i 45).

Tasowanie listy: Fisher-Yates

Żeby ułożyć listę w losowej kolejności, przejdź od końca i zamieniaj każdy element z losowym elementem na tej samej lub wcześniejszej pozycji. To tasowanie Fishera-Yatesa; jest szybkie, a każde ułożenie jest równie prawdopodobne. Zapisane jako metoda generyczna działa dla tablic i list o dowolnym typie elementów:

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

Wynik:

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

Dwa skróty, które zobaczysz w internecie, są gorsze. list.OrderBy(x => rng.Next()) działa, ale sortuje, więc jest wolniejsze, a losowe klucze mogą się powtórzyć. Zamiana z rng.Next(items.Count) zamiast rng.Next(i + 1) wygląda podobnie, ale sprawia, że niektóre ułożenia są bardziej prawdopodobne od innych. W .NET 8 i nowszych Random.Shared.Shuffle(array) poprawnie tasuje tablicę w miejscu, a rng.GetItems(choices, 5) losuje pięć elementów (z powtórzeniami).

Pułapka new Random() w pętli

Klasyczny błąd to tworzenie nowego Random za każdym razem, gdy potrzebna jest liczba:

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

W .NET Framework new Random() bez ziarna używa zegara systemowego (Environment.TickCount), który zmienia się tylko co 10 do 16 milisekund. Wywołania w szybkiej pętli tworzą instancje z tym samym ziarnem i zwracają tę samą liczbę, więc pętla rzutów kostką wypisuje 4 4 4 4 4. .NET Core i .NET 5+ dają każdej instancji ziarno ze wspólnego losowego źródła, co ukrywa objaw, ale tworzenie obiektu na każdą liczbę nadal jest marnotrawstwem, a kod psuje się po ponownym użyciu w starszych projektach albo w Unity.

Rozwiązaniem jest jedna instancja na klasę, przechowywana w polu:

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

Wynik:

3 6 6 5 6 1 2 1

Ziarno jest tu tylko po to, żeby przykład za każdym razem wypisywał to samo; w prawdziwej grze napisałbyś new Random().

Wątki i Random.Shared

Random nie jest bezpieczny wątkowo. Jeśli dwa wątki wywołają jednocześnie Next na tej samej instancji, jej stan wewnętrzny może się uszkodzić; znany objaw to instancja, która od tej pory zwraca 0. Możliwości, od najprostszej:

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 to właściwy wybór domyślny w nowym kodzie: jest bezpieczny wątkowo, nie wymaga pola i ma losowe ziarno. Nie da się mu nadać ziarna, więc gdy potrzebujesz powtarzalności, użyj własnego new Random(seed).

Kryptograficznie bezpieczne liczby losowe

System.Random jest z założenia przewidywalny. Każdy, kto zna ziarno albo zobaczy wystarczająco dużo wyników, może obliczyć resztę. To w porządku w grach i przy próbkowaniu, ale źle przy hasłach, tokenach resetu, identyfikatorach sesji, kluczach i losowaniach loterii. Do nich używaj RandomNumberGenerator z System.Security.Cryptography, który czyta z bezpiecznego generatora systemu operacyjnego:

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

Przykładowy wynik:

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

RandomNumberGenerator.GetInt32 (dostępne od .NET Core 3.0) zwraca nieobciążoną liczbę całkowitą z zakresu. Nie buduj bezpiecznych kodów przez bytes[0] % 10: modulo sprawia, że niektóre cyfry są bardziej prawdopodobne od innych. W .NET 6 i nowszych RandomNumberGenerator.GetBytes(16) zwraca od razu nową tablicę, a Convert.ToHexString(bytes) ją formatuje. Dla unikalnych identyfikatorów, przy których tajność nie ma znaczenia, prostszy jest Guid.NewGuid().

Najczęściej zadawane pytania

Jak wylosować liczbę w C#?

Utwórz jeden obiekt Random i wywołaj Next: var rng = new Random(); int roll = rng.Next(1, 7); daje od 1 do 6. Next(max) daje od 0 do max - 1, a NextDouble() daje double od 0.0 do 1.0, bez 1.0. W .NET 6 i nowszych możesz pominąć obiekt i użyć Random.Shared.Next(1, 7).

Czy górna granica Random.Next jest włączona?

Nie. Next(min, max) zwraca liczbę większą lub równą min i ściśle mniejszą od max. Dla liczby od 1 do 10 włącznie napisz Next(1, 11). Dzięki temu Next(0, list.Count) jest zawsze poprawnym indeksem listy.

Dlaczego new Random() daje te same liczby?

W .NET Framework new Random() bierze ziarno z zegara systemowego, który zmienia się tylko co kilka milisekund, więc kilka instancji utworzonych w szybkiej pętli dostaje to samo ziarno i ten sam ciąg. .NET Core i .NET 5+ dają każdej instancji inne ziarno, ale rozwiązanie jest wszędzie takie samo: utwórz jeden Random i używaj go wielokrotnie.

Jak za każdym razem dostać te same liczby losowe w C#?

Przekaż ziarno do konstruktora: new Random(42). Dwie instancje z tym samym ziarnem dają ten sam ciąg, dzięki czemu testy, symulacje i generowanie proceduralne są powtarzalne. Ciąg dla danego ziarna może różnić się między wersjami .NET, więc nie zapisuj wyników z ziarnem jako trwałych danych.

Czy System.Random jest wystarczająco bezpieczny do haseł lub tokenów?

Nie. Random jest przewidywalny: każdy, kto pozna jego stan lub ziarno, może odtworzyć liczby. Do haseł, tokenów, kluczy i wszystkiego, co związane z bezpieczeństwem, używaj System.Security.Cryptography.RandomNumberGenerator, na przykład RandomNumberGenerator.GetInt32(0, 10) albo RandomNumberGenerator.GetBytes(32).

Powiązane zagadnienia