How to generate a random number in a range in C#

int min = 1;
int max = 6;

// Next(minValue, maxValue): minValue is included, maxValue is not
int roll = Random.Shared.Next(min, max + 1);
Console.WriteLine($"roll is between 1 and 6: {roll >= min && roll <= max}");

// 10,000 draws: which values actually come up?
var seen = new SortedSet<int>();
for (int i = 0; i < 10_000; i++)
{
    seen.Add(Random.Shared.Next(min, max + 1));
}
Console.WriteLine($"values seen: {string.Join(", ", seen)}");

// Forget the + 1 and max never comes up
var withoutPlusOne = new SortedSet<int>();
for (int i = 0; i < 10_000; i++)
{
    withoutPlusOne.Add(Random.Shared.Next(min, max));
}
Console.WriteLine($"without + 1: {string.Join(", ", withoutPlusOne)}");

// Next(maxValue) counts from 0; negative ranges work the same way
int index = Random.Shared.Next(10);
int temperature = Random.Shared.Next(-10, 11);
Console.WriteLine($"0..9: {index is >= 0 and <= 9}, -10..10: {temperature is >= -10 and <= 10}");

// An empty range returns minValue; a reversed range throws
Console.WriteLine($"Next(5, 5) = {Random.Shared.Next(5, 5)}");
try
{
    Random.Shared.Next(6, 5);
}
catch (ArgumentOutOfRangeException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

int min = 10;
int max = 20;

// A fixed seed gives the same sequence on every run
var random = new Random(42);
Console.WriteLine(string.Join(" ", Enumerable.Range(0, 8).Select(_ => random.Next(min, max + 1))));

// The same seed again: the same numbers
var again = new Random(42);
Console.WriteLine(string.Join(" ", Enumerable.Range(0, 8).Select(_ => again.Next(min, max + 1))));

// The bug: a new seeded Random per call restarts the sequence every time
Console.WriteLine(string.Join(" ", Enumerable.Range(0, 8).Select(_ => new Random(42).Next(min, max + 1))));

// .NET Core and .NET 5+: unseeded instances get independent random seeds
var values = new HashSet<int>();
for (int i = 0; i < 5; i++)
{
    values.Add(new Random().Next());
}
Console.WriteLine($"distinct values from 5 new Random(): {values.Count}");

// Random.Shared is safe to call from many threads at once
var counts = new int[7];
Parallel.For(0, 60_000, _ =>
{
    Interlocked.Increment(ref counts[Random.Shared.Next(1, 7)]);
});
Console.WriteLine($"parallel rolls: {counts.Sum()}, faces hit: {counts.Count(c => c > 0)}");

var random = new Random(42);

// NextDouble() returns 0.0 (inclusive) to 1.0 (exclusive): scale and shift it
double min = 5.0;
double max = 10.0;
for (int i = 0; i < 3; i++)
{
    double price = min + (max - min) * random.NextDouble();
    Console.WriteLine($"{price} -> {price:F2}");
}

// NextSingle() is the float version (.NET 6+)
float chance = random.NextSingle();
Console.WriteLine($"NextSingle: {chance}");

// NextInt64(min, max) for ranges past int.MaxValue (.NET 6+), max still exclusive
long big = random.NextInt64(5_000_000_000, 10_000_000_001);
Console.WriteLine($"NextInt64: {big}");

// Next() with no arguments: 0 to int.MaxValue - 1, never negative
bool allNonNegative = true;
for (int i = 0; i < 10_000; i++)
{
    allNonNegative &= Random.Shared.Next() >= 0;
}
Console.WriteLine($"Next() never negative: {allNonNegative}");

// Unseeded doubles in -1.0..1.0, checked instead of printed
bool allInRange = true;
for (int i = 0; i < 10_000; i++)
{
    double d = -1.0 + 2.0 * Random.Shared.NextDouble();
    allInRange &= d >= -1.0 && d < 1.0;
}
Console.WriteLine($"allInRange: {allInRange}");

using System.Runtime.InteropServices;

var random = new Random(42);

// Random.Shuffle (.NET 8+) shuffles an array or span in place
int[] deck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
random.Shuffle(deck);
Console.WriteLine($"array:  [{string.Join(", ", deck)}]");

// A List<T> in place: shuffle the span over its backing array
List<string> players = ["Ada", "Grace", "Linus", "Margaret", "Ken"];
random.Shuffle(CollectionsMarshal.AsSpan(players));
Console.WriteLine($"list:   [{string.Join(", ", players)}]");

// Before .NET 8: Fisher-Yates by hand, walking down from the end
List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8];
var rng = new Random(42);
for (int i = numbers.Count - 1; i > 0; i--)
{
    int j = rng.Next(i + 1);
    (numbers[i], numbers[j]) = (numbers[j], numbers[i]);
}
Console.WriteLine($"manual: [{string.Join(", ", numbers)}]");

// .NET 10 LINQ: Shuffle() returns a new shuffled sequence (unseeded)
List<int> source = [1, 2, 3, 4, 5, 6, 7, 8];
List<int> shuffled = source.Shuffle().ToList();
Console.WriteLine($"LINQ Shuffle keeps every item: {shuffled.Order().SequenceEqual(source)}, source untouched: {source[0] == 1}");

// Pick one item, several with repeats (GetItems, .NET 8+), several without repeats
string[] colors = ["red", "green", "blue", "yellow"];
var picker = new Random(7);
Console.WriteLine($"one:     {colors[picker.Next(colors.Length)]}");
Console.WriteLine($"repeats: {string.Join(", ", picker.GetItems(colors, 5))}");
string[] copy = [.. colors];
picker.Shuffle(copy);
Console.WriteLine($"unique:  {string.Join(", ", copy[..2])}");

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

const string Alphanumeric = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

// .NET 10: Random.GetString picks length characters from an alphabet
Console.WriteLine(new Random(42).GetString(Alphanumeric, 12));

// .NET 8 and 9: GetItems returns a char[]
Console.WriteLine(new string(new Random(42).GetItems<char>(Alphanumeric, 12)));

// Older .NET: the classic LINQ one-liner
var random = new Random(42);
Console.WriteLine(new string(Enumerable.Repeat(Alphanumeric, 12)
    .Select(s => s[random.Next(s.Length)]).ToArray()));

// Secrets: RandomNumberGenerator, never Random (.NET 8+ for GetString)
string code = RandomNumberGenerator.GetString(Alphanumeric, 12);
Console.WriteLine($"code: {code.Length} chars, alphanumeric: {code.All(char.IsAsciiLetterOrDigit)}");

// A secure int in a range: GetInt32(fromInclusive, toExclusive)
string otp = RandomNumberGenerator.GetInt32(0, 1_000_000).ToString("D6");
Console.WriteLine($"otp: {otp.Length} digits, numeric: {otp.All(char.IsAsciiDigit)}");

// Tokens: random bytes, then encode them
byte[] bytes = RandomNumberGenerator.GetBytes(32);
string hex = Convert.ToHexString(bytes);
string token = Base64Url.EncodeToString(bytes); // .NET 9+
Console.WriteLine($"hex token: {hex.Length} chars, base64url token: {token.Length} chars");