Ausführbare C#-Docs: Zufallszahlen

Q: Wie erzeuge ich in C# eine Zufallszahl?

Erzeuge ein Random-Objekt und rufe Next auf: var rng = new Random(); int roll = rng.Next(1, 7); liefert 1 bis 6. Next(max) liefert 0 bis max - 1, und NextDouble() liefert ein double von 0.0 bis ausschließlich 1.0. Ab .NET 6 kannst du dir das Objekt sparen und Random.Shared.Next(1, 7) verwenden.

Q: Ist die Obergrenze von Random.Next inklusive?

Nein. Next(min, max) gibt eine Zahl zurück, die größer oder gleich min und echt kleiner als max ist. Für eine Zahl von 1 bis einschließlich 10 schreibe Next(1, 11). Dadurch ist Next(0, list.Count) ein gültiger Index in eine Liste.

Q: Warum liefert new Random() dieselben Zahlen?

Unter .NET Framework wird new Random() mit der Systemuhr geseedet, die sich nur alle paar Millisekunden ändert. Mehrere Instanzen, die schnell hintereinander in einer Schleife erzeugt werden, bekommen daher denselben Seed und dieselbe Folge. .NET Core und .NET 5+ seeden jede Instanz anders, aber die Lösung ist überall dieselbe: ein Random erzeugen und wiederverwenden.

Q: Wie bekomme ich in C# jedes Mal dieselben Zufallszahlen?

Übergib dem Konstruktor einen Seed: new Random(42). Zwei Instanzen mit demselben Seed erzeugen dieselbe Folge, was Tests, Simulationen und prozedurale Generierung reproduzierbar macht. Die Folge für einen Seed kann sich zwischen .NET-Versionen unterscheiden, speichere geseedete Ausgaben also nicht als dauerhafte Daten.

Q: Ist System.Random sicher genug für Passwörter oder Tokens?

Nein. Random ist vorhersagbar: Wer seinen Zustand oder Seed kennt, kann die Zahlen reproduzieren. Für Passwörter, Tokens, Schlüssel und alles Sicherheitsrelevante nimm System.Security.Cryptography.RandomNumberGenerator, zum Beispiel RandomNumberGenerator.GetInt32(0, 10) oder RandomNumberGenerator.GetBytes(32).

Die Klasse System.Random erzeugt Pseudozufallszahlen: eine deterministische Folge, die zufällig aussieht und von einem Seed ausgeht. Erzeuge eine Instanz und rufe ihre Methoden auf:

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

Beispielausgabe:

1294270287
83
You rolled a 5
0.6060

Führe es erneut aus, und die Zahlen ändern sich. Die Obergrenze ist exklusiv: Next(1, 7) kann 1, 2, 3, 4, 5 oder 6 zurückgeben, nie 7. Für eine Zahl zwischen 1 und einschließlich 10 schreibe Next(1, 11). Ist max kleiner als min, wird eine ArgumentOutOfRangeException geworfen.

Zufallszahlen in einem Bereich

Next(min, max) deckt Ganzzahlen ab. Für ein double in einem Bereich skaliere NextDouble(); für ein decimal wie einen Preis baue es aus Ganzzahlen, damit das Ergebnis die gewünschte Genauigkeit hat:

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

Beispielausgabe:

23.6 C
72.42
heads
N
-3

rng.Next(100, 10000) / 100m wählt eine ganze Zahl von Cent und teilt durch ein decimal, der Preis hat also immer genau zwei Nachkommastellen. Ein skaliertes double ergäbe Werte wie 72.4183.

Seeds: reproduzierbare Folgen

Ein ganzzahliger Seed macht die Folge wiederholbar. Zwei Random-Objekte mit demselben Seed erzeugen genau dieselben Zahlen in derselben Reihenfolge:

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

Ausgabe:

16 29 91 99 91
16 29 91 99 91
38

Seeds sind das Richtige für Tests, Simulationen, die du erneut ausführen musst, Replays in Spielen und prozedural generierte Level („World Seed 2026“). Protokolliere den verwendeten Seed, dann lässt sich ein überraschendes Ergebnis später reproduzieren.

Microsoft garantiert nicht, dass ein Seed in jeder .NET-Version dieselbe Folge erzeugt. Speichere geseedete Ausgaben nicht als Daten (etwa Kunden-IDs aus einem festen Seed erzeugen und erwarten, sie nach einem Upgrade neu erzeugen zu können).

Ein zufälliges Element wählen

Ein zufälliger Index ist Next(0, count), und der ist immer gültig, weil die Obergrenze exklusiv ist:

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

Ausgabe:

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

Die gewichtete Ziehung bildet eine Zahl von 0 bis 99 auf Bereiche ab, deren Größen die Gewichte sind: 0 bis 69 ist common, 70 bis 94 rare, 95 bis 99 legendary. Über 1.000 Ziehungen landen die Zählungen nahe bei 700, 250 und 50 (hier 695, 260 und 45).

Eine Liste mischen: Fisher-Yates

Um eine Liste in zufällige Reihenfolge zu bringen, gehst du vom Ende aus und tauschst jedes Element mit einem zufälligen Element an derselben oder einer früheren Position. Das ist der Fisher-Yates-Algorithmus; er ist schnell, und jede Reihenfolge ist gleich wahrscheinlich. Als generische Methode geschrieben funktioniert er für Arrays und Listen mit beliebigem Elementtyp:

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

Ausgabe:

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

Zwei Abkürzungen, die du online findest, sind schlechter. list.OrderBy(x => rng.Next()) funktioniert, sortiert aber, ist also langsamer, und zufällige Schlüssel können kollidieren. Mit rng.Next(items.Count) statt rng.Next(i + 1) zu tauschen sieht ähnlich aus, macht aber manche Reihenfolgen wahrscheinlicher als andere. Ab .NET 8 mischt Random.Shared.Shuffle(array) korrekt an Ort und Stelle, und rng.GetItems(choices, 5) wählt fünf zufällige Elemente (mit Wiederholung).

Die Falle mit new Random() in einer Schleife

Ein klassischer Bug ist, jedes Mal ein neues Random zu erzeugen, wenn eine Zahl gebraucht wird:

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

Unter .NET Framework verwendet new Random() ohne Seed die Systemuhr (Environment.TickCount), die sich nur alle 10 bis 16 Millisekunden ändert. Schnell hintereinander in einer Schleife erzeugte Instanzen bekommen denselben Seed und liefern dieselbe Zahl, eine Schleife mit Würfelwürfen gibt also 4 4 4 4 4 aus. .NET Core und .NET 5+ seeden jede Instanz aus einer gemeinsamen Zufallsquelle, was das Symptom verbirgt, aber ein Objekt pro Zahl zu erzeugen ist trotzdem verschwenderisch, und der Code bricht, wenn er in älteren Projekten oder in Unity wiederverwendet wird.

Die Lösung ist eine Instanz für die Klasse, gespeichert in einem Feld:

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

Ausgabe:

3 6 6 5 6 1 2 1

Der Seed steht hier nur, damit das Beispiel bei jedem Lauf dasselbe ausgibt; in einem echten Spiel würdest du new Random() schreiben.

Threads und Random.Shared

Random ist nicht threadsicher. Rufen zwei Threads gleichzeitig Next auf derselben Instanz auf, kann ihr interner Zustand beschädigt werden; das bekannte Symptom ist eine Instanz, die ab da nur noch 0 zurückgibt. Die Optionen, von der einfachsten an:

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 ist in neuem Code der richtige Standard: Es ist threadsicher, braucht kein Feld und wird zufällig geseedet. Es lässt sich nicht seeden, nimm also dein eigenes new Random(seed), wenn du Reproduzierbarkeit brauchst.

Kryptografisch sichere Zufallszahlen

System.Random ist absichtlich vorhersagbar. Wer den Seed kennt oder genug Ausgaben sieht, kann den Rest berechnen. Für Spiele und Stichproben ist das in Ordnung, für Passwörter, Reset-Tokens, Session-IDs, Schlüssel und Verlosungen falsch. Dafür nimmst du RandomNumberGenerator aus System.Security.Cryptography, der aus dem sicheren Generator des Betriebssystems liest:

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

Beispielausgabe:

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

RandomNumberGenerator.GetInt32 (ab .NET Core 3.0 verfügbar) gibt eine unverzerrte Ganzzahl im Bereich zurück. Baue sichere Codes nicht mit bytes[0] % 10: Der Modulo macht manche Ziffern wahrscheinlicher als andere. Ab .NET 6 gibt RandomNumberGenerator.GetBytes(16) direkt ein neues Array zurück, und Convert.ToHexString(bytes) formatiert es. Für eindeutige Bezeichner, bei denen Geheimhaltung keine Rolle spielt, ist Guid.NewGuid() einfacher.

Häufig gestellte Fragen

Wie erzeuge ich in C# eine Zufallszahl?

Erzeuge ein Random-Objekt und rufe Next auf: var rng = new Random(); int roll = rng.Next(1, 7); liefert 1 bis 6. Next(max) liefert 0 bis max - 1, und NextDouble() liefert ein double von 0.0 bis ausschließlich 1.0. Ab .NET 6 kannst du dir das Objekt sparen und Random.Shared.Next(1, 7) verwenden.

Ist die Obergrenze von Random.Next inklusive?

Nein. Next(min, max) gibt eine Zahl zurück, die größer oder gleich min und echt kleiner als max ist. Für eine Zahl von 1 bis einschließlich 10 schreibe Next(1, 11). Dadurch ist Next(0, list.Count) ein gültiger Index in eine Liste.

Warum liefert new Random() dieselben Zahlen?

Unter .NET Framework wird new Random() mit der Systemuhr geseedet, die sich nur alle paar Millisekunden ändert. Mehrere Instanzen, die schnell hintereinander in einer Schleife erzeugt werden, bekommen daher denselben Seed und dieselbe Folge. .NET Core und .NET 5+ seeden jede Instanz anders, aber die Lösung ist überall dieselbe: ein Random erzeugen und wiederverwenden.

Wie bekomme ich in C# jedes Mal dieselben Zufallszahlen?

Übergib dem Konstruktor einen Seed: new Random(42). Zwei Instanzen mit demselben Seed erzeugen dieselbe Folge, was Tests, Simulationen und prozedurale Generierung reproduzierbar macht. Die Folge für einen Seed kann sich zwischen .NET-Versionen unterscheiden, speichere geseedete Ausgaben also nicht als dauerhafte Daten.

Ist System.Random sicher genug für Passwörter oder Tokens?

Nein. Random ist vorhersagbar: Wer seinen Zustand oder Seed kennt, kann die Zahlen reproduzieren. Für Passwörter, Tokens, Schlüssel und alles Sicherheitsrelevante nimm System.Security.Cryptography.RandomNumberGenerator, zum Beispiel RandomNumberGenerator.GetInt32(0, 10) oder RandomNumberGenerator.GetBytes(32).

Verwandte Konzepte