How can I generate random alphanumeric strings

Question

How can I generate a random 8 character alphanumeric string in C

User · Answer

Here is a mechanism to generate a random alpha-numeric string (I use this to generate passwords and test data) without defining the alphabet and numbers,

CleanupBase64 will remove necessary parts in the string and keep adding random alpha-numeric letters recursively.

        public static string GenerateRandomString(int length)
        {
            var numArray = new byte[length];
            new RNGCryptoServiceProvider().GetBytes(numArray);
            return CleanUpBase64String(Convert.ToBase64String(numArray), length);
        }

        private static string CleanUpBase64String(string input, int maxLength)
        {
            input = input.Replace("-", "");
            input = input.Replace("=", "");
            input = input.Replace("/", "");
            input = input.Replace("+", "");
            input = input.Replace(" ", "");
            while (input.Length < maxLength)
                input = input + GenerateRandomString(maxLength);
            return input.Length <= maxLength ?
                input.ToUpper() : //In my case I want capital letters
                input.ToUpper().Substring(0, maxLength);
        }

User · Answer

not 100  sure  as I didn t test EVERY option here  but of the ones I did test  this one is the fastest  timed it with stopwatch and it showed 9-10 ticks so if speed is more important than security  try this    private static Random random   new Random      public static string Random int length                      var stringChars   new char length              for  int i   0  i  lt  length  i                                      stringChars i     char random Next 0x30  0x7a                                       return new string stringChars

User · Answer

Question  Why should I waste my time using Enumerable Range instead of typing in  ABCDEFGHJKLMNOPQRSTUVWXYZ0123456789    using System  using System Collections Generic  using System Linq   public class Test       public static void Main                 var randomCharacters   GetRandomCharacters 8  true           Console WriteLine new string randomCharacters ToArray                 private static List lt char gt  getAvailableRandomCharacters bool includeLowerCase                var integers   Enumerable Empty lt int gt             integers   integers Concat Enumerable Range  A   26            integers   integers Concat Enumerable Range  0   10             if   includeLowerCase               integers   integers Concat Enumerable Range  a   26             return integers Select i   gt   char i  ToList               public static IEnumerable lt char gt  GetRandomCharacters int count  bool includeLowerCase                var characters   getAvailableRandomCharacters includeLowerCase           var random   new Random            var result   Enumerable Range 0  count               Select     gt  characters random Next characters Count              return result              Answer  Magic strings are BAD  Did ANYONE notice there was no  I  in my string at the top  My mother taught me not to use magic strings for this very reason     n b  1  As many others like  dtb said  don t use System Random if you need cryptographic security     n b  2  This answer isn t the most efficient or shortest  but I wanted the space to separate the answer from the question  The purpose of my answer is more to warn against magic strings than to provide a fancy innovative answer

User · Answer

Very simple solution  It uses ASCII values and just generates  random  characters in between them   public static class UsernameTools       public static string GenerateRandomUsername int length   10                Random random   new Random            StringBuilder sbuilder   new StringBuilder            for  int x   0  x  lt  length    x                        sbuilder Append  char random Next 33  126                      return sbuilder ToString

User · Answer

We also use custom string random but we implemented is as a string s helper so it provides some flexibility      public static string Random this string chars  int length   8        var randomString   new StringBuilder        var random   new Random         for  int i   0  i  lt  length  i            randomString Append chars random Next chars Length          return randomString ToString        Usage  var random    ABCDEFGHIJKLMNOPQRSTUVWXYZ  Random      or  var random    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789  Random 16

User · Answer

The simplest   public static string GetRandomAlphaNumeric         return Path GetRandomFileName   Replace          Substring 0  8       You can get better performance if you hard code the char array and rely on System Random   public static string GetRandomAlphaNumeric         var chars    abcdefghijklmnopqrstuvwxyz0123456789       return new string chars Select c   gt  chars random Next chars Length    Take 8  ToArray         If ever you worry the English alphabets can change sometime around and you might lose business  then you can avoid hard coding  but should perform slightly worse  comparable to Path GetRandomFileName approach   public static string GetRandomAlphaNumeric         var chars    a  To  z   Concat  0  To  9    ToList        return new string chars Select c   gt  chars random Next chars Length    Take 8  ToArray        public static IEnumerable lt char gt  To this char start  char end        if  end  lt  start          throw new ArgumentOutOfRangeException  the end char should not be less than start char   innerException  null       return Enumerable Range start  end - start   1  Select i   gt   char i       The last two approaches looks better if you can make them an extension method on System Random instance

User · Answer

Here is a variant of Eric J s solution  i e  cryptographically sound  for WinRT  Windows Store App    public static string GenerateRandomString int length        var chars    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890       var result   new StringBuilder length       for  int i   0  i  lt  length    i                result Append CryptographicBuffer GenerateRandomNumber     chars Length             return result ToString        If performance matters  especially when length is high    public static string GenerateRandomString int length        var chars    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890       var result   new System Text StringBuilder length       var bytes   CryptographicBuffer GenerateRandom  uint length   4  ToArray        for  int i   0  i  lt  bytes Length  i    4                result Append BitConverter ToUInt32 bytes  i    chars Length             return result ToString

User · Answer

Here s an example that I stole from Sam Allen example at Dot Net Perls  If you only need 8 characters  then use Path GetRandomFileName   in the System IO namespace  Sam says using the  Path GetRandomFileName method here is sometimes superior  because it uses RNGCryptoServiceProvider for better randomness  However  it is limited to 11 random characters    GetRandomFileName always returns a 12 character string with a period at the 9th character  So you ll need to strip the period  since that s not random  and then take 8 characters from the string  Actually  you could just take the first 8 characters and not worry about the period   public string Get8CharacterRandomString         string path   Path GetRandomFileName        path   path Replace              Remove period      return path Substring 0  8       Return 8 character string     PS  thanks Sam

User · Answer

One line of code Membership GeneratePassword   does the trick      Here is a demo for the same

User · Answer

After reviewing the other answers and considering CodeInChaos  comments  along with CodeInChaos still biased  although less  answer  I thought a final ultimate cut and paste solution was needed  So while updating my answer I decided to go all out   For an up to date version of this code  please visit the new Hg repository on Bitbucket  https   bitbucket org merarischroeder secureswiftrandom  I recommend you copy and paste the code from  https   bitbucket org merarischroeder secureswiftrandom src 6c14b874f34a3f6576b0213379ecdf0ffc7496ea Code Alivate SolidSwiftRandom SolidSwiftRandom cs at default amp fileviewer file-view-default  make sure you click the Raw button to make it easier to copy and make sure you have the latest version  I think this link goes to a specific version of the code  not the latest    Updated notes    Relating to some other answers - If you know the length of the output  you don t need a StringBuilder  and when using ToCharArray  this creates and fills the array  you don t need to create an empty array first  Relating to some other answers - You should use NextBytes  rather than getting one at a time for performance Technically you could pin the byte array for faster access   it s usually worth it when your iterating more than 6-8 times over a byte array   Not done here  Use of RNGCryptoServiceProvider for best randomness Use of caching of a 1MB buffer of random data - benchmarking shows cached single bytes access speed is  1000x faster - taking 9ms over 1MB vs 989ms for uncached  Optimised rejection of bias zone within my new class    End solution to question   static char   charSet     abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789  ToCharArray    static int byteSize   256    Labelling convenience static int biasZone   byteSize -  byteSize   charSet Length   public string GenerateRandomString int Length    Configurable output string length       byte   rBytes   new byte Length     Do as much before and after lock as possible     char   rName   new char Length       SecureFastRandom GetNextBytesMax rBytes  biasZone       for  var i   0  i  lt  Length  i                  rName i    charSet rBytes i    charSet Length             return new string rName       But you need my new  untested  class        lt summary gt      My benchmarking showed that for RNGCryptoServiceProvider      1  There is negligable benefit of sharing RNGCryptoServiceProvider object reference      2  Initial GetBytes takes 2ms  and an initial read of 1MB takes 3ms  starting to rise  but still negligable      2  Cached is  1000x faster for single byte at a time - taking 9ms over 1MB vs 989ms for uncached      lt  summary gt  class SecureFastRandom       static byte   byteCache   new byte 1000000     My benchmark showed that an initial read takes 2ms  and an initial read of this size takes 3ms  starting to raise      static int lastPosition   0      static int remaining   0            lt summary gt          Static direct uncached access to the RNGCryptoServiceProvider GetBytes function          lt  summary gt           lt param name  buffer  gt  lt  param gt      public static void DirectGetBytes byte   buffer                using  var r   new RNGCryptoServiceProvider                          r GetBytes buffer                             lt summary gt          Main expected method to be called by user  Underlying random data is cached from RNGCryptoServiceProvider for best performance          lt  summary gt           lt param name  buffer  gt  lt  param gt      public static void GetBytes byte   buffer                if  buffer Length  gt  byteCache Length                        DirectGetBytes buffer               return                     lock  byteCache                        if  buffer Length  gt  remaining                                DirectGetBytes byteCache                   lastPosition   0                  remaining   byteCache Length                             Buffer BlockCopy byteCache  lastPosition  buffer  0  buffer Length               lastPosition    buffer Length              remaining -  buffer Length                            lt summary gt          Return a single byte from the cache of random data           lt  summary gt           lt returns gt  lt  returns gt      public static byte GetByte                 lock  byteCache                        return UnsafeGetByte                              lt summary gt          Shared with public GetByte and GetBytesWithMax  and not locked to reduce lock unlocking in loops  Must be called within lock of byteCache           lt  summary gt           lt returns gt  lt  returns gt      static byte UnsafeGetByte                 if  1  gt  remaining                        DirectGetBytes byteCache               lastPosition   0              remaining   byteCache Length                     lastPosition            remaining--          return byteCache lastPosition - 1                   lt summary gt          Rejects bytes which are equal to or greater than max  This is useful for ensuring there is no bias when you are modulating with a non power of 2 number           lt  summary gt           lt param name  buffer  gt  lt  param gt           lt param name  max  gt  lt  param gt      public static void GetBytesWithMax byte   buffer  byte max                if  buffer Length  gt  byteCache Length   2    No point caching for larger sizes                       DirectGetBytes buffer                lock  byteCache                                UnsafeCheckBytesMax buffer  max                                   else                       lock  byteCache                                if  buffer Length  gt  remaining    Recache if not enough remaining  discarding remaining - too much work to join two blocks                     DirectGetBytes byteCache                    Buffer BlockCopy byteCache  lastPosition  buffer  0  buffer Length                   lastPosition    buffer Length                  remaining -  buffer Length                   UnsafeCheckBytesMax buffer  max                                           lt summary gt          Checks buffer for bytes equal and above max  Must be called within lock of byteCache           lt  summary gt           lt param name  buffer  gt  lt  param gt           lt param name  max  gt  lt  param gt      static void UnsafeCheckBytesMax byte   buffer  byte max                for  int i   0  i  lt  buffer Length  i                          while  buffer i   gt   max                  buffer i    UnsafeGetByte      Replace all bytes which are equal or above max                     For history - my older solution for this answer  used Random object       private static char   charSet          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789  ToCharArray         static rGen   new Random      Must share  because the clock seed only has Ticks   10ms  resolution  yet lock has only 20-50ns delay      static int byteSize   256    Labelling convenience     static int biasZone   byteSize -  byteSize   charSet Length       static bool SlightlyMoreSecurityNeeded   true    Configuration - needs to be true  if more security is desired and if charSet Length is not divisible by 2 X      public string GenerateRandomString int Length    Configurable output string length             byte   rBytes   new byte Length     Do as much before and after lock as possible       char   rName   new char Length         lock  rGen     20-50ns                   rGen NextBytes rBytes              for  int i   0  i  lt  Length  i                              while  SlightlyMoreSecurityNeeded  amp  amp  rBytes i   gt   biasZone    Secure against 1 5 increased bias of index 0-7  values against others  Note  Must exclude where it    biasZone  that is  gt     otherwise there s still a bias on index 0                    rBytes i    rGen NextByte                  rName i    charSet rBytes i    charSet Length                             return new string rName           Performance    SecureFastRandom - First single run    9-33ms  Imperceptible  Ongoing  5ms  sometimes it goes up to 13ms  over 10 000 iterations  With a single average iteration  1 5 microseconds   Note  Requires generally 2  but occasionally up to 8 cache refreshes - depends on how many single bytes exceed the bias zone   Random  - First single run    0-1ms  Imperceptible  Ongoing  5ms over 10 000 iterations  With a single average iteration   5 microseconds   About the same speed    Also check out    https   bitbucket org merarischroeder number-range-with-no-bias src https   stackoverflow com a 45118325 887092   These links are another approach  Buffering could be added to this new code base  but most important was exploring different approaches to removing bias  and benchmarking the speeds and pros cons

User · Answer

I know this one is not the best way  But you can try this   string str   Path GetRandomFileName      This method returns a random file name of 11 characters str   str Replace          Console WriteLine  Random string      str

User · Answer

My simple one line code works for me     string  random   string Join     Guid NewGuid   ToString  n   Take 8  Select o   gt  o     Response Write random ToUpper     Response Write random ToLower       To expand on this for any length string      public static string RandomString int length                  length   length  lt  0   length   -1   length          var str                do                        str    Guid NewGuid   ToString   Replace  -                           while  length  gt  str Length            return str Substring 0  length

User · Answer

public static class StringHelper       private static readonly Random random   new Random         private const int randomSymbolsDefaultCount   8      private const string availableChars    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789        private static int randomSymbolsIndex   0       public static string GetRandomSymbols                 return GetRandomSymbols randomSymbolsDefaultCount              public static string GetRandomSymbols int count                var index   randomSymbolsIndex          var result   new string              Enumerable Repeat availableChars  count                         Select s   gt                              index    random Next s Length                             if  index  gt   s Length                                index -  s Length                            return s index                                                   ToArray             randomSymbolsIndex   index          return result

User · Answer

The main goals of my code are    The distribution of strings is almost uniform  don t care about minor deviations  as long as they re small  It outputs more than a few billion strings for each argument set  Generating an 8 character string   47 bits of entropy  is meaningless if your PRNG only generates 2 billion  31 bits of entropy  different values  It s secure  since I expect people to use this for passwords or other security tokens    The first property is achieved by taking a 64 bit value modulo the alphabet size  For small alphabets  such as the 62 characters from the question  this leads to negligible bias  The second and third property are achieved by using RNGCryptoServiceProvider instead of System Random   using System  using System Security Cryptography   public static string GetRandomAlphanumericString int length        const string alphanumericCharacters            ABCDEFGHIJKLMNOPQRSTUVWXYZ             abcdefghijklmnopqrstuvwxyz             0123456789       return GetRandomString length  alphanumericCharacters      public static string GetRandomString int length  IEnumerable lt char gt  characterSet        if  length  lt  0          throw new ArgumentException  length must not be negative    length        if  length  gt  int MaxValue   8     250 million chars ought to be enough for anybody         throw new ArgumentException  length is too big    length        if  characterSet    null          throw new ArgumentNullException  characterSet        var characterArray   characterSet Distinct   ToArray        if  characterArray Length    0          throw new ArgumentException  characterSet must not be empty    characterSet         var bytes   new byte length   8       var result   new char length       using  var cryptoProvider   new RNGCryptoServiceProvider                  cryptoProvider GetBytes bytes             for  int i   0  i  lt  length  i                  ulong value   BitConverter ToUInt64 bytes  i   8           result i    characterArray value    uint characterArray Length             return new string result

User · Answer

UPDATED based on comments  The original implementation generated a-h  1 95  of the time and the remaining characters  1 56  of the time  The update generates all characters  1 61  of the time  FRAMEWORK SUPPORT -  NET Core 3  and future platforms that support  NET Standard 2 1 or above  provides a cryptographically sound method RandomNumberGenerator GetInt32   to generate a random integer within a desired range   Unlike some of the alternatives presented  this one is cryptographically sound  using System  using System Security Cryptography  using System Text   namespace UniqueKey       public class KeyGenerator               internal static readonly char   chars                quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 quot  ToCharArray              public static string GetUniqueKey int size                                    byte   data   new byte 4 size               using  RNGCryptoServiceProvider crypto   new RNGCryptoServiceProvider                                  crypto GetBytes data                             StringBuilder result   new StringBuilder size               for  int i   0  i  lt  size  i                                  var rnd   BitConverter ToUInt32 data  i   4                   var idx   rnd   chars Length                   result Append chars idx                               return result ToString                       public static string GetUniqueKeyOriginal BIASED int size                        char   chars                    quot abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 quot  ToCharArray                byte   data   new byte size               using  RNGCryptoServiceProvider crypto   new RNGCryptoServiceProvider                                  crypto GetBytes data                             StringBuilder result   new StringBuilder size               foreach  byte b in data                                result Append chars b    chars Length                               return result ToString                       Based on a discussion of alternatives here and updated modified based on the comments below  Here s a small test harness that demonstrates the distribution of characters in the old and updated output  For a deep discussion of the analysis of randomness  check out random org  using System  using System Collections Generic  using System Linq  using UniqueKey   namespace CryptoRNGDemo       class Program                const int REPETITIONS   1000000          const int KEY SIZE   32           static void Main string   args                        Console WriteLine  quot Original BIASED implementation quot                PerformTest REPETITIONS  KEY SIZE  KeyGenerator GetUniqueKeyOriginal BIASED                Console WriteLine  quot Updated implementation quot                PerformTest REPETITIONS  KEY SIZE  KeyGenerator GetUniqueKey               Console ReadKey                       static void PerformTest int repetitions  int keySize  Func lt int  string gt  generator                        Dictionary lt char  int gt  counts   new Dictionary lt char  int gt                 foreach  var ch in UniqueKey KeyGenerator chars  counts Add ch  0                for  int i   0  i  lt  REPETITIONS  i                                  var key   generator KEY SIZE                    foreach  var ch in key  counts ch                                int totalChars   counts Values Sum                foreach  var ch in UniqueKey KeyGenerator chars                                Console WriteLine   quot  ch     100 0   counts ch    totalChars  ToString  quot   000 quot     quot

User · Answer

Horrible  I know  but I just couldn t help myself     namespace ConsoleApplication2       using System      using System Text RegularExpressions       class Program               static void Main string   args                        Random adomRng   new Random                string rndString   string Empty              char c               for  int i   0  i  lt  8  i                                  while   Regex IsMatch  c Convert ToChar adomRng Next 48 128    ToString      A-Za-z0-9                      rndString    c                             Console WriteLine rndString   Environment NewLine

User · Answer

Solution 1 - largest  range  with most flexible length  string get unique string int string length        using var rng   new RNGCryptoServiceProvider              var bit count    string length   6           var byte count     bit count   7    8      rounded up         var bytes   new byte byte count           rng GetBytes bytes           return Convert ToBase64String bytes             This solution has more range than using a GUID because a GUID has a couple of fixed bits that are always the same and therefore not random  for example the 13 character in hex is always  4  - at least in a version 6 GUID   This solution also lets you generate a string of any length   Solution 2 - One line of code - good for up to 22 characters  Convert ToBase64String Guid NewGuid   ToByteArray    Substring 0  8     You can t generate strings as long as Solution 1 and the string doesn t have the same range due to fixed bits in GUID s  but in a lot of cases this will do the job   Solution 3 - Slightly less code  Guid NewGuid   ToString  n   Substring 0  8     Mostly keeping this here for historical purpose  It uses slightly less code  that though comes as the expense of having less range - because it uses hex instead of base64 it takes more characters to represent the same range compared the other solutions   Which means more chance of collision - testing it with 100 000 iterations of 8 character strings generated one duplicate

User · Answer

Now in one-liner flavour   private string RandomName             return new string              Enumerable Repeat  ABCDEFGHIJKLMNOPQRSTUVWXYZ   13                   Select s   gt                                        var cryptoResult   new byte 4                       using  var cryptoProvider   new RNGCryptoServiceProvider                            cryptoProvider GetBytes cryptoResult                        return s new Random BitConverter ToInt32 cryptoResult  0   Next s Length                                        ToArray

User · Answer

I heard LINQ is the new black  so here s my attempt using LINQ   private static Random random   new Random    public static string RandomString int length        const string chars    ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789       return new string Enumerable Repeat chars  length         Select s   gt  s random Next s Length    ToArray          Note  The use of the Random class makes this unsuitable for anything security related  such as creating passwords or tokens  Use the RNGCryptoServiceProvider class if you need a strong random number generator

User · Answer

If your values are not completely random  but in fact may depend on something - you may compute an md5 or sha1 hash of that  somwthing  and then truncate it to whatever length you want   Also you may generate and truncate a guid

User · Answer

The code written by Eric J  is quite sloppy  it is quite clear that it is from 6 years ago    he probably wouldn t write that code today   and there are even some problems      Unlike some of the alternatives presented  this one is cryptographically sound    Untrue    There is a bias in the password  as written in a comment   bcdefgh are a little more probable than the others  the a isn t because by the GetNonZeroBytes it isn t generating bytes with a value of zero  so the bias for the a is balanced by it   so it isn t really cryptographically sound   This should correct all the problems   public static string GetUniqueKey int size   6  string chars    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890         using  var crypto   new RNGCryptoServiceProvider                  var data   new byte size               If chars Length isn t a power of 2 then there is a bias if            we simply use the modulus operator  The first characters of            chars will be more probable than the last ones              buffer used if we encounter an unusable random byte  We will            regenerate it in this buffer         byte   smallBuffer   null              Maximum random number that can be used without introducing a            bias         int maxRandom   byte MaxValue -   byte MaxValue   1    chars Length            crypto GetBytes data            var result   new char size            for  int i   0  i  lt  size  i                          byte v   data i                while  v  gt  maxRandom                                if  smallBuffer    null                                        smallBuffer   new byte 1                                      crypto GetBytes smallBuffer                   v   smallBuffer 0                              result i    chars v   chars Length                      return new string result

User · Answer

Just some performance comparisons of the various answers in this thread   Methods  amp  Setup     what s available public static string possibleChars    abcdefghijklmnopqrstuvwxyz      optimized     what s available public static char   possibleCharsArray   possibleChars ToCharArray       optimized  precalculated  count public static int possibleCharsAvailable   possibleChars Length     shared randomization thingy public static Random random   new Random         http   stackoverflow com a 1344242 1037948 public string LinqIsTheNewBlack int num        return new string      Enumerable Repeat possibleCharsArray  num                 Select s   gt  s random Next s Length                   ToArray           http   stackoverflow com a 1344258 1037948 public string ForLoop int num        var result   new char num       while num--  gt  0            result num    possibleCharsArray random Next possibleCharsAvailable              return new string result      public string ForLoopNonOptimized int num        var result   new char num       while num--  gt  0            result num    possibleChars random Next possibleChars Length              return new string result      public string Repeat int num        return new string new char num  Select o   gt  possibleCharsArray random Next possibleCharsAvailable    ToArray           http   stackoverflow com a 1518495 1037948 public string GenerateRandomString int num      var rBytes   new byte num     random NextBytes rBytes     var rName   new char num     while num--  gt  0      rName num    possibleCharsArray rBytes num    possibleCharsAvailable     return new string rName        SecureFastRandom - or SolidSwiftRandom static string GenerateRandomString int Length    Configurable output string length       byte   rBytes   new byte Length        char   rName   new char Length       SolidSwiftRandom GetNextBytesWithMax rBytes  biasZone       for  var i   0  i  lt  Length  i                  rName i    charSet rBytes i    charSet Length             return new string rName       Results  Tested in LinqPad   For string size of 10  generates         from Linq   chdgmevhcy  10    from Loop   gtnoaryhxr  10    from Select   rsndbztyby  10    from GenerateRandomString   owyefjjakj  10    from SecureFastRandom   VzougLYHYP  10    from SecureFastRandom-NoCache   oVQXNGmO1S  10       And the performance numbers tend to vary slightly  very occasionally NonOptimized is actually faster  and sometimes ForLoop and GenerateRandomString switch who s in the lead         LinqIsTheNewBlack  10000x    96762 ticks elapsed  9 6762 ms     ForLoop  10000x    28970 ticks elapsed  2 897 ms    ForLoopNonOptimized  10000x    33336 ticks elapsed  3 3336 ms    Repeat  10000x    78547 ticks elapsed  7 8547 ms    GenerateRandomString  10000x    27416 ticks elapsed  2 7416 ms    SecureFastRandom  10000x    13176 ticks elapsed  5ms  lowest  Different machine    SecureFastRandom-NoCache  10000x    39541 ticks elapsed  17ms  lowest  Different machine

User · Answer

I was looking for a more specific answer  where I want to control the format of the random string and came across this post   For example  license plates  of cars  have a specific format  per country  and I wanted to created random license plates  I decided to write my own extension method of Random for this    this is in order to reuse the same Random object  as you could have doubles in multi-threading scenarios   I created a gist  https   gist github com SamVanhoutte 808845ca78b9c041e928   but will also copy the extension class here    void Main         Random rnd   new Random        rnd GetString  1-   -000   Dump       public static class RandomExtensions       public static string GetString this Random random  string format                   Based on http   stackoverflow com questions 1344221 how-can-i-generate-random-alphanumeric-strings-in-c            Added logic to specify the format of the random string    will be random string  0 will be random numeric  other characters remain          StringBuilder result   new StringBuilder            for int formatIndex   0  formatIndex  lt  format Length   formatIndex                          switch format ToUpper   formatIndex                                 case  0   result Append getRandomNumeric random    break                  case      result Append getRandomCharacter random    break                  default   result Append format formatIndex    break                                  return result ToString               private static char getRandomCharacter Random random                string chars    ABCDEFGHIJKLMNOPQRSTUVWXYZ           return chars random Next chars Length               private static char getRandomNumeric Random random                string nums    0123456789           return nums random Next nums Length

User · Answer

I don t know how cryptographically sound this is  but it s more readable and concise than the more intricate solutions by far  imo   and it should be more  random  than System Random-based solutions   return alphabet      OrderBy c   gt  Guid NewGuid         Take strLength       Aggregate          new StringBuilder             builder  c    gt  builder Append c        ToString      I can t decide if I think this version or the next one is  prettier   but they give the exact same results   return new string alphabet      OrderBy o   gt  Guid NewGuid         Take strLength       ToArray       Granted  it isn t optimized for speed  so if it s mission critical to generate millions of random strings every second  try another one   NOTE  This solution doesn t allow for repetitions of symbols in the alphabet  and the alphabet MUST be of equal or greater size than the output string  making this approach less desirable in some circumstances  it all depends on your use-case

User · Answer

var chars    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789   var stringChars   new char 8   var random   new Random     for  int i   0  i  lt  stringChars Length  i          stringChars i    chars random Next chars Length       var finalString   new String stringChars     Not as elegant as the Linq solution    Note  The use of the Random class makes this unsuitable for anything security related  such as creating passwords or tokens  Use the RNGCryptoServiceProvider class if you need a strong random number generator

User · Answer

Another option could be to use Linq and aggregate random chars into a stringbuilder   var  chars      abcdefghijklmnopqrstuvwxyz123456789  ToArray    string pw    Enumerable Range 0   passwordLength                         Aggregate                            new  StringBuilder                               sb   n     gt   sb Append  chars random Next chars Length                                 sb    gt   sb ToString

User · Answer

Try to combine two parts  unique  sequence  counter or date   and random public class RandomStringGenerator       public static string Gen                 return ConvertToBase DateTime UtcNow ToFileTimeUtc      GenRandomStrings 5     keep length fixed at least of one part            private static string GenRandomStrings int strLen                var result   string Empty           using  var gen   new RNGCryptoServiceProvider                          var data   new byte 1                while  result Length  lt  strLen                                gen GetNonZeroBytes data                   int code   data 0                   if  code  gt  48  amp  amp  code  lt  57       0-9                     code  gt  65  amp  amp  code  lt  90       A-Z                     code  gt  97  amp  amp  code  lt  122      a-z                                                         result    Convert ToChar code                                                return result                       private static string ConvertToBase long num  int nbase   36                const string chars    quot 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ quot     if you wish to make the algorithm more secure - change order of letter here             check if we can convert to another base         if  nbase  lt  2    nbase  gt  chars Length              return null           int r          var newNumber   string Empty              in r we have the offset of the char that was converted to the new base         while  num  gt   nbase                        r    int  num   nbase               newNumber   chars r    newNumber              num   num   nbase                       the last number to convert         newNumber   chars  int num    newNumber           return newNumber           Tests       Test      public void Generator Should BeUnigue1                   Given         var loop   Enumerable Range 0  1000             When         var str   loop Select x  gt  RandomStringGenerator Gen               Then         var distinct   str Distinct            Assert AreEqual loop Count   distinct Count        Or Assert IsTrue distinct Count    lt  0 95   loop Count

User · Answer

There is one  of the awasome nuget packages that make this so simple    var myObject   new Faker lt MyObject gt     RuleFor p   gt  p MyAlphaNumericProperty  f   gt  f Random AlphaNumeric   lenght   7    Generate      One of the good example is here

User · Answer

A solution without using Random    var chars   Enumerable Repeat  ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789   8    var randomStr   new string chars SelectMany str   gt  str                                   OrderBy c   gt  Guid NewGuid                                     Take 8  ToArray

User · Answer

You just use the assembly SRVTextToImage  And write below code to generate random string   CaptchaRandomImage c1   new CaptchaRandomImage                string text   c1 GetRandomString 8     Mostly it is used to implement the Captcha  But in your case it also works  Hope it helps

User · Answer

public static string RandomString int length                const string chars    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789           var random   new Random            return new string Enumerable Repeat chars  length  Select s   gt  s random Next s Length    ToArray

User · Answer

A slightly cleaner version of DTB s solution       var chars    ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789       var random   new Random        var list   Enumerable Repeat 0  8  Select x  gt chars random Next chars Length         return string Join     list     Your style preferences may vary

User · Answer

For both crypto  amp  noncrypto  efficiently   private static readonly Random  random   new Random     public static string GenerateRandomString int length  string charset    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890     gt      RandomString  random NextBytes  length  charset ToCharArray      public static string GenerateRandomCryptoString int length  string charset    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890         using  var crypto   new System Security Cryptography RNGCryptoServiceProvider            return RandomString crypto GetBytes  length  charset ToCharArray        private static string RandomString Action lt byte   gt  fillRandomBuffer  int length  char   charset        if  length  lt  0          throw new ArgumentOutOfRangeException nameof length      nameof length   must be greater or equal to 0        if  charset is null          throw new ArgumentNullException nameof charset        if  charset Length    0          throw new ArgumentException    nameof charset   must contain at least 1 character   nameof charset         var maxIdx   charset Length      var chars   new char length       var randomBuffer   new byte length   4       fillRandomBuffer randomBuffer        for  var i   0  i  lt  length  i            chars i    charset BitConverter ToUInt32 randomBuffer  i   4    maxIdx        return new string chars       Using generators  amp  LINQ  Not the fastest option  especially because it doesn t generate all the bytes in one go  but pretty neat  amp  extensible   private static readonly Random  random   new Random     public static string GenerateRandomString int length  string charset    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890     gt      new string  random GetGenerator   RandomChars charset ToCharArray    Take length  ToArray      public static string GenerateRandomCryptoString int length  string charset    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890         using  var crypto   new System Security Cryptography RNGCryptoServiceProvider            return new string crypto GetGenerator   RandomChars charset ToCharArray    Take length  ToArray        public static IEnumerable lt char gt  RandomChars this Func lt uint  IEnumerable lt uint gt  gt  randomGenerator  char   charset        if  charset is null          throw new ArgumentNullException nameof charset        if  charset Length    0          throw new ArgumentException    nameof charset   must contain at least 1 character   nameof charset         return randomGenerator  uint charset Length  Select r   gt  charset r       public static Func lt uint  IEnumerable lt uint gt  gt  GetGenerator this Random random        if  random is null          throw new ArgumentNullException nameof random         return GeneratorFunc Inner       IEnumerable lt uint gt  GeneratorFunc Inner uint maxValue                if  maxValue  gt  int MaxValue              throw new ArgumentOutOfRangeException nameof maxValue             return Generator Inner             IEnumerable lt uint gt  Generator Inner                         var randomBytes   new byte 4               while  true                                random NextBytes randomBytes                   yield return BitConverter ToUInt32 randomBytes  0    maxValue                                   public static Func lt uint  IEnumerable lt uint gt  gt  GetGenerator this System Security Cryptography RNGCryptoServiceProvider random        if  random is null          throw new ArgumentNullException nameof random         return Generator Inner       IEnumerable lt uint gt  Generator Inner uint maxValue                var randomBytes   new byte 4           while  true                        random GetBytes randomBytes               yield return BitConverter ToUInt32 randomBytes  0    maxValue                      a simpler version using LINQ for only non-crypto strings   private static readonly Random  random   new Random     public static string RandomString int length  string charset    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890     gt      new string  random GenerateChars charset  Take length  ToArray       public static IEnumerable lt char gt  GenerateChars this Random random  string charset        if  charset is null  throw new ArgumentNullException nameof charset        if  charset Length    0  throw new ArgumentException    nameof charset   must contain at least 1 character   nameof charset         return random Generator charset Length  Select r   gt  charset r       public static IEnumerable lt int gt  Generator this Random random  int maxValue        if  random is null  throw new ArgumentNullException nameof random         return Generator Inner         IEnumerable lt int gt  Generator Inner     while  true  yield return random Next maxValue

[c#] How can I generate random alphanumeric strings?

Examples related to c#

Examples related to .net

Examples related to random