How do I generate a random integer in C#?

To generate a random integer in C#, you can use the Random class for general-purpose randomness or RandomNumberGenerator (for cryptographic security). Here’s how to do it:

1. Using `Random` Class (Basic Randomness)

For most scenarios (games, simulations, non-security-critical use cases):

// Create a single instance and reuse it (avoids duplicate values)
Random random = new Random();

// Generate a random integer between 0 and Int32.MaxValue
int num1 = random.Next();

// Generate between 0 (inclusive) and 10 (exclusive)
int num2 = random.Next(10);

// Generate between 5 (inclusive) and 20 (exclusive)
int num3 = random.Next(5, 20);

Important Notes:

Reuse the Random instance: Creating new Random() repeatedly in quick succession can produce duplicate values due to seed reuse.
Thread Safety: Use lock or Random.Shared (in .NET 6+) for multi-threaded code:

  // .NET 6+ thread-safe shared instance
  int num = Random.Shared.Next(1, 100);

2. Using `RandomNumberGenerator` (Cryptographically Secure)

For security-sensitive applications (e.g., passwords, tokens):

using System.Security.Cryptography;

// Generate a random integer between 0 (inclusive) and 100 (exclusive)
int secureNum = RandomNumberGenerator.GetInt32(100);

// Generate between 10 (inclusive) and 50 (exclusive)
int secureNumInRange = RandomNumberGenerator.GetInt32(10, 50);

Notes:

Available in .NET Core 3.0+.
Slower than Random but suitable for security-critical tasks.

3. Common Pitfalls & Best Practices

Mistake: Incorrect range (exclusive upper bound)

// WRONG: Returns 0-99 (not 1-100)
int wrong = random.Next(1, 100);

// CORRECT: Returns 1-100 inclusive
int correct = random.Next(1, 101);

Mistake: Creating multiple `Random` instances in a loop

// Avoid this in loops (same seed = duplicate values)
for (int i = 0; i < 5; i++)
{
    Random badRandom = new Random(); // Risk of duplicates
    Console.WriteLine(badRandom.Next());
}

Best Practice: Static instance for reuse

public static class RandomHelper
{
    private static readonly Random _random = new Random();

    public static int GetRandom(int min, int max)
    {
        return _random.Next(min, max);
    }
}

Full Example

using System;
using System.Security.Cryptography;

public class Program
{
    static Random _random = new Random();

    public static void Main()
    {
        // Basic random number (1-100 inclusive)
        int basicRandom = _random.Next(1, 101);
        Console.WriteLine($"Basic Random: {basicRandom}");

        // Cryptographically secure random (1-100 inclusive)
        int secureRandom = RandomNumberGenerator.GetInt32(1, 101);
        Console.WriteLine($"Secure Random: {secureRandom}");
    }
}

Summary

General Use: Random class with Next(), Next(min, max), or Random.Shared (.NET 6+).
Security Use: RandomNumberGenerator.GetInt32().
Avoid Pitfalls: Reuse Random instances and understand exclusive upper bounds.

1. Using Random Class (Basic Randomness)