I need to generate 7 characters of alphanumeric string. With a small search I wrote the below code. Performance results are uploaded above

I have used hashtable Class to guarantee uniqueness and also used RNGCryptoServiceProvider Class to get high-quality random chars

Code of generating unique string part is below;

public static Tuple<List<string>, List<string>> GenerateUniqueList(int count)
    {
        uniqueHashTable = new Hashtable();
        nonUniqueList = new List<string>();
        uniqueList = new List<string>();

        for (int i = 0; i < count; i++)
        {
            isUniqueGenerated = false;

            while (!isUniqueGenerated)
            {
                uniqueStr = GetUniqueKey();
                try
                {
                    uniqueHashTable.Add(uniqueStr, "");
                    isUniqueGenerated = true;
                }
                catch (Exception ex)
                {
                    nonUniqueList.Add(uniqueStr);
                    // Non-unique generated
                }
            }
        }

        uniqueList = uniqueHashTable.Keys.Cast<string>().ToList();

        return new Tuple<List<string>, List<string>>(uniqueList, nonUniqueList);
    }

    public static string GetUniqueKey()
    {
        int size = 7;
        char[] chars = new char[62];
        string a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        chars = a.ToCharArray();

        RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();

        byte[] data = new byte[size];
        crypto.GetNonZeroBytes(data);

        StringBuilder result = new StringBuilder(size);

        foreach (byte b in data)
            result.Append(chars[b % (chars.Length - 1)]);

        return Convert.ToString(result);
    }

Whole Console Application Code below;

class Program
{
    static string uniqueStr;
    static Stopwatch stopwatch;
    static bool isUniqueGenerated;
    static Hashtable uniqueHashTable;
    static List<string> uniqueList;
    static List<string> nonUniqueList;
    static Tuple<List<string>, List<string>> generatedTuple;

    static void Main(string[] args)
    {
        int i = 0, y = 0, count = 100000;

        while (i < 10 && y < 4)
        {
            stopwatch = new Stopwatch();

            stopwatch.Start();

            generatedTuple = GenerateUniqueList(count);

            stopwatch.Stop();

            Console.WriteLine("Time elapsed: {0} --- {1} Unique  --- {2} nonUnique",
                stopwatch.Elapsed,
                generatedTuple.Item1.Count().ToFormattedInt(),
                generatedTuple.Item2.Count().ToFormattedInt());

            i++;
            if (i == 9)
            {
                Console.WriteLine(string.Empty);
                y++;
                count *= 10;
                i = 0;
            }
        }


        Console.ReadLine();
    }

    public static Tuple<List<string>, List<string>> GenerateUniqueList(int count)
    {
        uniqueHashTable = new Hashtable();
        nonUniqueList = new List<string>();
        uniqueList = new List<string>();

        for (int i = 0; i < count; i++)
        {
            isUniqueGenerated = false;

            while (!isUniqueGenerated)
            {
                uniqueStr = GetUniqueKey();
                try
                {
                    uniqueHashTable.Add(uniqueStr, "");
                    isUniqueGenerated = true;
                }
                catch (Exception ex)
                {
                    nonUniqueList.Add(uniqueStr);
                    // Non-unique generated
                }
            }
        }

        uniqueList = uniqueHashTable.Keys.Cast<string>().ToList();

        return new Tuple<List<string>, List<string>>(uniqueList, nonUniqueList);
    }

    public static string GetUniqueKey()
    {
        int size = 7;
        char[] chars = new char[62];
        string a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        chars = a.ToCharArray();

        RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
 
        byte[] data = new byte[size];
        crypto.GetNonZeroBytes(data);

        StringBuilder result = new StringBuilder(size);

        foreach (byte b in data)
            result.Append(chars[b % (chars.Length - 1)]);

        return Convert.ToString(result);
    }
}

public static class IntExtensions
{
    public static string ToFormattedInt(this int value)
    {
        return string.Format(CultureInfo.InvariantCulture, "{0:0,0}", value);
    }
}

I believe that the main problem is not the generation method but the uniqueness of the data.

As I understand there is a database and you have to check the generated data uniqueness retrospectively with your past data generated.

Suppose that there is a new requirement that your business side ask for another 100.000 unique data from you. And you have already generated 10.000.000 in the past. Which are stored in DB.

My suggestion will be;

1 - Generate for example 120.000 unique key ( greater than the requirement )

2 - Bulk insert those data to a temp table.

3 - Then execute a stored procedure to compare two tables in the SQL Server side,

4 - if your temp table contains 100.000 different value from your old 10.000.000 dataset, then you are good to go insert those 100.000 to your main table return them to your business side, else, for example 60.000 of 120.000 is different from your old data set but 60.000 is same, in this situation your stored procedure can return int = 40.000 which you will understand that you need another 40.000 data.

Go to the step 1, Execute your generator for another 60.000, 100.000 whatever you want and follow the same steps.

May not be the best solution but I believe will be fast. Because generating 1.000.000 of random alphanumeric strings take at most 2 seconds with the code below;

In the past I have used the below code to generate unique random data

public static string GetUniqueKey()
    {
        int size = 7;
        char[] chars = new char[62];
        string a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        chars = a.ToCharArray();

        RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();

        byte[] data = new byte[size];
        crypto.GetNonZeroBytes(data);

        StringBuilder result = new StringBuilder(size);

        foreach (byte b in data)
            result.Append(chars[b % (chars.Length - 1)]);

        return Convert.ToString(result);
    }

and for the uniqueness of my runtime generated data, I have used a hashtable as can be seen above.

public static Tuple<List<string>, List<string>> GenerateUniqueList(int count)
    {
        uniqueHashTable = new Hashtable();
        nonUniqueList = new List<string>();
        uniqueList = new List<string>();

        for (int i = 0; i < count; i++)
        {
            isUniqueGenerated = false;

            while (!isUniqueGenerated)
            {
                uniqueStr = GetUniqueKey();
                try
                {
                    uniqueHashTable.Add(uniqueStr, "");
                    isUniqueGenerated = true;
                }
                catch (Exception ex)
                {
                    nonUniqueList.Add(uniqueStr);
                    // Non-unique generated
                }
            }
        }

        uniqueList = uniqueHashTable.Keys.Cast<string>().ToList();

        return new Tuple<List<string>, List<string>>(uniqueList, nonUniqueList);
    }