How to generate random alphanumeric string from a given string in C#?

Question

I have a string. I want to generate a random string from this string, by replacing a number by a random number. lower character by lower character and upper character by upper character. And remaining characters as it is.

I have written the below code. I need to call this method millions of time on different strings (string length is not more than 100 characters), It's taking too much time.

private static string GenerateRandomAlphanumericValue(string input) {
    char[] newStr = new char[input.Length];
    char[] alphaU = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
    char[] alphaL = "abcdefghijklmnopqrstuvwxyz".ToCharArray();
    char[] number = "0123456789".ToCharArray();
    Random random = new Random();
    for (int i = 0; i < input.Length; i++) {
        if (char.IsNumber(input[i])) {

            int index = random.Next(0, number.Length);
            newStr[i] = number[index];
        }
        else if (char.IsUpper(input[i])) {
            int index = random.Next(0, alphaU.Length);
            newStr[i] = alphaU[index];
        }
        else if (char.IsLower(input[i])) {
            int index = random.Next(0, alphaL.Length);
            newStr[i] = alphaL[index];
        }
        else {
            newStr[i] = input[i];
        }
    }

    return string.Join("", newStr);
}

I need help in optimizing the code or there any be a different approach to solve the problem.

Input: vivEK123$% ~a

Output: ajrLW854$% ~w

Answer 1

Try this

static char[] alphaU = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
static char[] alphaL = "abcdefghijklmnopqrstuvwxyz".ToCharArray();
static char[] number = "0123456789".ToCharArray();
static Random random = new Random();
static StringBuilder sb = new StringBuilder(100);

private static string GenerateRandomAlphanumericValue(string input)
{
    sb.Clear();
    for (int i = 0; i < input.Length; i++)
    {
        if (char.IsNumber(input[i]))
        {
            int index = random.Next(0, number.Length);
            sb.Append(number[index]);
        }
        else if (char.IsUpper(input[i]))
        {
            int index = random.Next(0, alphaU.Length);
            sb.Append(alphaU[index]);
        }
        else if (char.IsLower(input[i]))
        {
            int index = random.Next(0, alphaL.Length);
            sb.Append(alphaL[index]);
        }
        else
        {
            sb.Append(input[i]);
        }
    }

    return sb.ToString();
}

Answer 2

Instead of using arrays, you could just randomize based on the ASCII-value range of characters. I'd also suggest using StringBuilder to build the result string.

public class Randomizer{
    private static Random rng = new Random();
    public static string RandomizeString(string input){
        StringBuilder sb = new StringBuilder();
        foreach(char c in input){
            if(Char.IsNumber(c)){
                sb.Append(rng.Next(0,10));
            }
            else if(Char.IsLower(c)){
                sb.Append((char)rng.Next(97,123));
            }
            else if(Char.IsUpper(c)){
                sb.Append((char)rng.Next(65,91));
            }
            else{
                sb.Append(c);
            }
        }
        return sb.ToString();
    }
}

Note: a-z is ASCII 97-122, A-Z is ASCII 65-90, and 0-9 is just an integer cast to a string.

Answer 3

This is a little more efficient. I'm not sure about execution time :

       private static string GenerateRandomAlphanumericValue(string input)
        {
            string newStr = "";
            string alphaU = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            string alphaL = "abcdefghijklmnopqrstuvwxyz";
            string number = "0123456789";
            Random random = new Random();
            for (int i = 0; i < input.Length; i++)
            {
                if (char.IsNumber(input[i]))
                {

                    int index = random.Next(0, number.Length);
                    newStr  += number[index];
                }
                else if (char.IsUpper(input[i]))
                {
                    int index = random.Next(0, alphaU.Length);
                    newStr += alphaU[index];
                }
                else if (char.IsLower(input[i]))
                {
                    int index = random.Next(0, alphaL.Length);
                    newStr += alphaL[index];
                }
                else
                {
                    newStr += input[i];
                }
            }

            return newStr;
        }

Answer 4

The general principle is to move as much as possible out of loops and to use the least expensive techniques inside loops.

Random only needs to be constructed once.

StringBuilder is one of the more efficient ways of moving individually acquire Chars into a String. And, it needs to be constructed only once (but introduces thread safety issues).

Array indexing is one fast way to replace chain logic but might not be the fastest since there are only three ranges. (if >= && <= times three could be faster.)

IsUpper et al might have a big impact on its performance. They have to account for all Unicode codepoints in the general category Lu, Ll or Nd.

private static readonly Random random = new Random();
private static readonly StringBuilder sb = new StringBuilder(100);

// min and max are the replacement range for indexing Char.
private static readonly Char[] min = new Char[Char.MaxValue + 1];
private static readonly Char[] max = new Char[Char.MaxValue + 1];

static UserQuery()
{
    foreach (var range in new[] { 
        (min: 'A', max: 'Z'), 
        (min: 'a', max: 'z'), 
        (min: '0', max: '9') })
    {
        for (var c = range.min; c <= range.max; c++)
        {
            min[c] = range.min;
            max[c] = range.max;
        }
    }
}

private static String GenerateRandomAlphanumericValue(String input)
{
    sb.Clear();
    foreach (var c in input)
    {
        sb.Append((Char)random.Next(min[c], max[c]));
    }
    return sb.ToString();  
}