Logo
Back

How can I generate random alphanumeric strings in C#?

Below are several ways to generate random alphanumeric strings (letters and digits) in C#, ranging from straightforward concatenations of characters to cryptographically secure solutions.

1. Simple Random Approach with System.Random

This approach uses a fixed character set (e.g., A-Z, a-z, 0-9) and picks characters randomly:

public static string GenerateRandomAlphanumeric(int length)
{
    const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    var random = new Random();
    var result = new char[length];

    for (int i = 0; i < length; i++)
    {
        result[i] = chars[random.Next(chars.Length)];
    }

    return new string(result);
}
  • Pros: Very easy to implement, good for non-critical use (e.g., test data).
  • Cons: Not cryptographically secure—seeding is time-based, and collisions may occur in high-volume or security-sensitive scenarios.

2. More Secure Approach with RandomNumberGenerator

For a cryptographically secure solution, use System.Security.Cryptography.RandomNumberGenerator (in .NET 6+, you can also use RandomNumberGenerator.GetInt32()):

using System.Security.Cryptography;

public static string GenerateSecureRandomAlphanumeric(int length)
{
    const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    char[] result = new char[length];

    byte[] randomBytes = new byte[length];
    RandomNumberGenerator.Fill(randomBytes);

    for (int i = 0; i < length; i++)
    {
        int randomIndex = randomBytes[i] % chars.Length;
        result[i] = chars[randomIndex];
    }

    return new string(result);
}
  • Pros: Harder to predict; suitable for tokens, passwords, or any scenario requiring cryptographic strength.
  • Cons: Slightly more complex code; performance overhead is higher compared to System.Random.

3. Using Guid or Convert.ToBase64String() (Less Direct Control)

You can also harness Guid.NewGuid() or base64-encoded random bytes to get an alphanumeric-like string, though the output may contain -, _, = or /:

public static string GuidToAlphanumeric(int length = 32)
{
    string guidString = Guid.NewGuid().ToString("N"); // e.g., "d33fe7454b404d0ebce63bd2f7e95f2b"
    return guidString[..Math.Min(length, guidString.Length)];
}
  • Pros: Very convenient, especially for generating unique identifiers.
  • Cons: May contain non-alphanumeric characters (in the base64 approach) or might require trimming/formatting to fit desired length and character set.

Best Practices

  1. Choose the Right Source
    • For non-sensitive IDs (like random filenames or casual “shuffling”), System.Random is typically enough.
    • For security tokens or passwords, always use a cryptographically secure random source (RandomNumberGenerator).
  2. Watch Length
    • Ensure the generated string length meets your app’s needs (password policies, user IDs, etc.).
  3. Performance
    • Generating random bytes with RandomNumberGenerator is slightly more expensive than System.Random; be mindful if you’re generating high volumes in tight loops.

Further Enhance Your C# Skills

To boost your coding foundations and learn pattern-based solutions to common interview problems, check out:

Visit the DesignGurus.io YouTube channel for in-depth discussions on coding patterns, system design, and interview tips. By using the right approach to random alphanumeric generation—whether a simple or cryptographically secure solution—you’ll ensure your C# applications remain both user-friendly and robust.

CONTRIBUTOR
TechGrind