¿Cómo puedo generar cadenas alfanuméricas aleatorias en C #?

¿Cómo puedo generar cadenas alfanuméricas aleatorias de 8 caracteres en C #?

Escuché que LINQ es el nuevo negro, así que aquí está mi bash de usar 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 => s[random.Next(s.Length)]).ToArray()); } 

( Nota: el uso de la clase Random hace que esto no sea adecuado para nada relacionado con la seguridad, como la creación de contraseñas o tokens.
Utilice la clase RNGCryptoServiceProvider si necesita un generador de números aleatorios fuerte).

 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; var stringChars = new char[8]; var random = new Random(); for (int i = 0; i < stringChars.Length; i++) { stringChars[i] = chars[random.Next(chars.Length)]; } var finalString = new String(stringChars); 

No tan elegante como la solución de Linq. (-:

(Nota: el uso de la clase Random lo hace inadecuado para cualquier cosa relacionada con la seguridad , como la creación de contraseñas o tokens. Utilice la clase RNGCryptoServiceProvider si necesita un generador de números aleatorios).

Esta implementación (encontrada a través de google) me parece buena.

A diferencia de algunas de las alternativas presentadas, esta es criptográficamente sólida .

 using System.Security.Cryptography; using System.Text; namespace UniqueKey { public class KeyGenerator { public static string GetUniqueKey(int maxSize) { char[] chars = new char[62]; chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".ToCharArray(); byte[] data = new byte[1]; using (RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider()) { crypto.GetNonZeroBytes(data); data = new byte[maxSize]; crypto.GetNonZeroBytes(data); } StringBuilder result = new StringBuilder(maxSize); foreach (byte b in data) { result.Append(chars[b % (chars.Length)]); } return result.ToString(); } } } 

Elegido ese de una discusión de alternativas aquí

Solución 1: el “rango” más grande con la longitud más flexible

 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); } } 

Esta solución tiene más scope que el uso de un GUID porque un GUID tiene un par de bits fijos que son siempre los mismos y por lo tanto no aleatorios, por ejemplo, los 13 caracteres en hexadecimal siempre son “4”, al menos en un GUID de versión 6.

Esta solución también te permite generar una cadena de cualquier longitud.

Solución 2 – Una línea de código – válida para hasta 22 caracteres

 Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8); 

No puede generar cadenas mientras Solución 1 y la cadena no tiene el mismo rango debido a bits fijos en GUID, pero en muchos casos esto hará el trabajo.

Solución 3: poco menos código

 Guid.NewGuid().ToString("n").Substring(0, 8); 

Sobre todo mantener esto aquí con un propósito histórico. Utiliza un código ligeramente menor, que a pesar de que se trata del gasto de tener menos rango, porque usa hexadecimal en lugar de base64, se necesitan más caracteres para representar el mismo rango en comparación con las otras soluciones.

Lo que significa más posibilidades de colisión: probarlo con 100,000 iteraciones de 8 cadenas de caracteres generó un duplicado.

Aquí hay un ejemplo que robé del ejemplo de Sam Allen en Dot Net Perls

Si solo necesita 8 caracteres, use Path.GetRandomFileName () en el espacio de nombres System.IO. Sam dice que usar el método “Path.GetRandomFileName aquí es a veces superior, porque usa RNGCryptoServiceProvider para una mejor aleatoriedad. Sin embargo, está limitado a 11 caracteres aleatorios”.

GetRandomFileName siempre devuelve una cadena de 12 caracteres con un punto en el noveno carácter. Por lo tanto, necesitará quitar el período (ya que no es aleatorio) y luego tomar 8 caracteres de la cadena. En realidad, puedes tomar los primeros 8 caracteres y no preocuparte por el período.

 public string Get8CharacterRandomString() { string path = Path.GetRandomFileName(); path = path.Replace(".", ""); // Remove period. return path.Substring(0, 8); // Return 8 character string } 

PD: gracias Sam

Los principales objectives de mi código son:

  1. La distribución de las cadenas es casi uniforme (no se preocupan por desviaciones menores, siempre que sean pequeñas)
  2. Genera más de unos mil millones de cadenas para cada conjunto de argumentos. Generar una cadena de 8 caracteres (~ 47 bits de entropía) no tiene sentido si su PRNG solo genera valores diferentes de 2 billones (31 bits de entropía).
  3. Es seguro, ya que espero que las personas lo usen para contraseñas u otros tokens de seguridad.

La primera propiedad se logra tomando un módulo de valor de 64 bit el tamaño del alfabeto. Para los pequeños alfabetos (como los 62 caracteres de la pregunta) esto lleva a un sesgo insignificante. La segunda y tercera propiedad se logran utilizando RNGCryptoServiceProvider lugar de 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 characterSet) { if (length < 0) throw new ArgumentException("length must not be negative", "length"); if (length > 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]; new RNGCryptoServiceProvider().GetBytes(bytes); var result = new char[length]; for (int i = 0; i < length; i++) { ulong value = BitConverter.ToUInt64(bytes, i * 8); result[i] = characterArray[value % (uint)characterArray.Length]; } return new string(result); } 

Lo más simple:

 public static string GetRandomAlphaNumeric() { return Path.GetRandomFileName().Replace(".", "").Substring(0, 8); } 

Puede obtener un mejor rendimiento si codifica la matriz de caracteres y confía en System.Random :

 public static string GetRandomAlphaNumeric() { var chars = "abcdefghijklmnopqrstuvwxyz0123456789"; return new string(chars.Select(c => chars[random.Next(chars.Length)]).Take(8).ToArray()); } 

Si alguna vez te preocupas, los alfabetos ingleses pueden cambiar en algún momento y podrías perder negocios, entonces puedes evitar la encoding difícil, pero debería funcionar un poco peor (comparable al enfoque Path.GetRandomFileName )

 public static string GetRandomAlphaNumeric() { var chars = 'a'.To('z').Concat('0'.To('9')).ToList(); return new string(chars.Select(c => chars[random.Next(chars.Length)]).Take(8).ToArray()); } public static IEnumerable To(this char start, char end) { if (end < 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 => (char)i); } 

Los dos últimos enfoques se ven mejor si puede convertirlos en un método de extensión en la instancia de System.Random .

Solo algunas comparaciones de rendimiento de las diversas respuestas en este hilo:

Métodos y configuración

 // 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 => s[random.Next(s.Length)]) .ToArray()); } // http://stackoverflow.com/a/1344258/1037948 public string ForLoop(int num) { var result = new char[num]; while(num-- > 0) { result[num] = possibleCharsArray[random.Next(possibleCharsAvailable)]; } return new string(result); } public string ForLoopNonOptimized(int num) { var result = new char[num]; while(num-- > 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 => 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-- > 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 < Length; i++) { rName[i] = charSet[rBytes[i] % charSet.Length]; } return new string(rName); } 

Resultados

Probado en LinqPad. Para un tamaño de cadena de 10, genera:

  • de Linq = chdgmevhcy [10]
  • de Loop = gtnoaryhxr [10]
  • de Select = rsndbztyby [10]
  • de GenerateRandomString = owyefjjakj [10]
  • de SecureFastRandom = VzougLYHYP [10]
  • de SecureFastRandom-NoCache = oVQXNGmO1S [10]

Y las cifras de rendimiento tienden a variar ligeramente, muy ocasionalmente NonOptimized es realmente más rápido, y algunas veces ForLoop y GenerateRandomString cambian quién está a la cabeza.

  • LinqIsTheNewBlack (10000x) = 96762 ticks transcurridos (9.6762 ms)
  • ForLoop (10000x) = 28970 tics transcurridos (2.897 ms)
  • ForLoopNonOptimized (10000x) = 33336 ticks transcurridos (3,3336 ms)
  • Repetir (10000x) = 78547 ticks transcurridos (7.8547 ms)
  • GenerateRandomString (10000x) = 27416 ticks transcurridos (2.7416 ms)
  • SecureFastRandom (10000x) = 13176 ticks transcurridos (5ms) más bajo [Máquina diferente]
  • SecureFastRandom-NoCache (10000x) = 39541 ticks transcurridos (17ms) más bajo [Máquina diferente]

Una línea de código Membership.GeneratePassword() hace el truco 🙂

Aquí hay una demostración de lo mismo.

El código escrito por Eric J. es bastante descuidado (está bastante claro que es de hace 6 años … probablemente no escribiría ese código hoy), e incluso hay algunos problemas.

A diferencia de algunas de las alternativas presentadas, esta es criptográficamente sólida.

Falso … Hay un sesgo en la contraseña (como está escrito en un comentario), bcdefgh son un poco más probables que los otros (el a no es porque el GetNonZeroBytes no está generando bytes con un valor de cero, por lo que el sesgo para el a está equilibrado), por lo que no es realmente criptográficamente sólido.

Esto debería corregir todos los problemas.

 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 < size; i++) { byte v = data[i]; while (v > maxRandom) { if (smallBuffer == null) { smallBuffer = new byte[1]; } crypto.GetBytes(smallBuffer); v = smallBuffer[0]; } result[i] = chars[v % chars.Length]; } return new string(result); } } 

También usamos cadenas personalizadas al azar, pero lo implementamos como ayudante de cuerdas, por lo que brinda cierta flexibilidad …

 public static string Random(this string chars, int length = 8) { var randomString = new StringBuilder(); var random = new Random(); for (int i = 0; i < length; i++) randomString.Append(chars[random.Next(chars.Length)]); return randomString.ToString(); } 

Uso

 var random = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Random(); 

o

 var random = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".Random(16); 

Otra opción podría ser utilizar Linq y agregar caracteres aleatorios en un generador de cadenas.

 var chars = "abcdefghijklmnopqrstuvwxyz123456789".ToArray(); string pw = Enumerable.Range(0, passwordLength) .Aggregate( new StringBuilder(), (sb, n) => sb.Append((chars[random.Next(chars.Length)])), sb => sb.ToString()); 

Pregunta: ¿Por qué debería perder el tiempo usando Enumerable.Range lugar de escribir "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 getAvailableRandomCharacters(bool includeLowerCase) { var integers = Enumerable.Empty(); 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 => (char)i).ToList(); } public static IEnumerable GetRandomCharacters(int count, bool includeLowerCase) { var characters = getAvailableRandomCharacters(includeLowerCase); var random = new Random(); var result = Enumerable.Range(0, count) .Select(_ => characters[random.Next(characters.Count)]); return result; } } 

Respuesta: Las cuerdas mágicas son MALAS. ¿Alguien notó que no había una ” I ” en mi cadena en la parte superior? Mi madre me enseñó a no usar cuerdas mágicas por esta misma razón …

nb 1: Como muchos otros como @dtb dijeron, no use System.Random si necesita seguridad criptográfica …

nb 2: Esta respuesta no es la más eficiente ni la más corta, pero quería el espacio para separar la respuesta de la pregunta. El propósito de mi respuesta es más para advertir contra cadenas mágicas que para proporcionar una respuesta innovadora y elegante.

Horrible, lo sé, pero no pude evitarlo:

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 < 8; i++) { while (!Regex.IsMatch((c=Convert.ToChar(adomRng.Next(48,128))).ToString(), "[A-Za-z0-9]")); rndString += c; } Console.WriteLine(rndString + Environment.NewLine); } } }
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 < 8; i++) { while (!Regex.IsMatch((c=Convert.ToChar(adomRng.Next(48,128))).ToString(), "[A-Za-z0-9]")); rndString += c; } Console.WriteLine(rndString + Environment.NewLine); } } } 

Estaba buscando una respuesta más específica, donde quiero controlar el formato de la cadena aleatoria y encontré esta publicación. Por ejemplo: las matrículas (de los automóviles) tienen un formato específico (por país) y quería crear matrículas aleatorias.
Decidí escribir mi propio método de extensión de Random para esto. (Esto es para reutilizar el mismo objeto Aleatorio, ya que podría tener dobles en escenarios de multi-threading). Creé un gist ( https://gist.github.com/SamVanhoutte/808845ca78b9c041e928 ), pero también copiaré la clase de extensión aquí:

 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 < 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)]; } } 

Una versión ligeramente más limpia de la solución de DTB.

  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; var random = new Random(); var list = Enumerable.Repeat(0, 8).Select(x=>chars[random.Next(chars.Length)]); return string.Join("", list); 

Sus preferencias de estilo pueden variar.

Mi código de una línea simple funciona para mí 🙂

 string random = string.Join("", Guid.NewGuid().ToString("n").Take(8).Select(o => o)); Response.Write(random.ToUpper()); Response.Write(random.ToLower()); 

Para ampliar esto para cualquier cadena de longitud

  public static string RandomString(int length) { //length = length < 0 ? length * -1 : length; var str = ""; do { str += Guid.NewGuid().ToString().Replace("-", ""); } while (length > str.Length); return str.Substring(0, length); } 

Intenta combinar dos partes: única (secuencia, contador o fecha) y aleatoria

 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; var Gen = new RNGCryptoServiceProvider(); var data = new byte[1]; while (result.Length < strLen) { Gen.GetNonZeroBytes(data); int code = data[0]; if (code > 48 && code < 57 || // 0-9 code > 65 && code < 90 || // AZ code > 97 && code < 122 // az ) { result += Convert.ToChar(code); } } return result; } private static string ConvertToBase(long num, int nbase = 36) { var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //if you wish make algoritm more secure - change order of letter here // check if we can convert to another base if (nbase < 2 || nbase > 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 >= nbase) { r = (int) (num % nbase); newNumber = chars[r] + newNumber; num = num / nbase; } // the last number to convert newNumber = chars[(int)num] + newNumber; return newNumber; } } 

Pruebas:

 [Test] public void Generator_Should_BeUnigue1() { //Given var loop = Enumerable.Range(0, 1000); //When var str = loop.Select(x=> RandomStringGenerator.Gen()); //Then var distinct = str.Distinct(); Assert.AreEqual(loop.Count(),distinct.Count()); // Or Assert.IsTrue(distinct.Count() < 0.95 * loop.Count()) } 
  public static string RandomString(int length) { const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; var random = new Random(); return new string(Enumerable.Repeat(chars, length).Select(s => s[random.Next(s.Length)]).ToArray()); } 

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&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:

  1. 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)
  2. Relating to some other answers – You should use NextBytes, rather than getting one at a time for performance
  3. 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)
  4. Use of RNGCryptoServiceProvider for best randomness
  5. 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.
  6. 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 < Length; i++) { rName[i] = charSet[rBytes[i] % charSet.Length]; } return new string(rName); } 

But you need my new (untested) class:

 ///  /// 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 ///  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; ///  /// Static direct uncached access to the RNGCryptoServiceProvider GetBytes function ///  ///  public static void DirectGetBytes(byte[] buffer) { using (var r = new RNGCryptoServiceProvider()) { r.GetBytes(buffer); } } ///  /// Main expected method to be called by user. Underlying random data is cached from RNGCryptoServiceProvider for best performance ///  ///  public static void GetBytes(byte[] buffer) { if (buffer.Length > byteCache.Length) { DirectGetBytes(buffer); return; } lock (byteCache) { if (buffer.Length > remaining) { DirectGetBytes(byteCache); lastPosition = 0; remaining = byteCache.Length; } Buffer.BlockCopy(byteCache, lastPosition, buffer, 0, buffer.Length); lastPosition += buffer.Length; remaining -= buffer.Length; } } ///  /// Return a single byte from the cache of random data. ///  ///  public static byte GetByte() { lock (byteCache) { return UnsafeGetByte(); } } ///  /// Shared with public GetByte and GetBytesWithMax, and not locked to reduce lock/unlocking in loops. Must be called within lock of byteCache. ///  ///  static byte UnsafeGetByte() { if (1 > remaining) { DirectGetBytes(byteCache); lastPosition = 0; remaining = byteCache.Length; } lastPosition++; remaining--; return byteCache[lastPosition - 1]; } ///  /// 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. ///  ///  ///  public static void GetBytesWithMax(byte[] buffer, byte max) { if (buffer.Length > byteCache.Length / 2) //No point caching for larger sizes { DirectGetBytes(buffer); lock (byteCache) { UnsafeCheckBytesMax(buffer, max); } } else { lock (byteCache) { if (buffer.Length > 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); } } } ///  /// Checks buffer for bytes equal and above max. Must be called within lock of byteCache. ///  ///  ///  static void UnsafeCheckBytesMax(byte[] buffer, byte max) { for (int i = 0; i < buffer.Length; i++) { while (buffer[i] >= 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 < Length; i++) { while (SlightlyMoreSecurityNeeded && rBytes[i] >= biasZone) //Secure against 1/5 increased bias of index[0-7] values against others. Note: Must exclude where it == biasZone (that is >=), otherwise there's still a bias on index 0. rBytes[i] = rGen.NextByte(); rName[i] = charSet[rBytes[i] % charSet.Length]; } } return new string(rName); } 

Actuación:

  1. 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
  2. Random - First single run = ~0-1ms . Imperceptible. Ongoing : 5ms over 10,000 iterations. With a single average iteration= .5 microseconds. . About the same speed.

Now in one-liner flavour.

 private string RandomName { get { return new string( Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 13) .Select(s => { var cryptoResult = new byte[4]; new RNGCryptoServiceProvider().GetBytes(cryptoResult); return s[new Random(BitConverter.ToInt32(cryptoResult, 0)).Next(s.Length)]; }) .ToArray()); } } 

A solution without using Random :

 var chars = Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 8); var randomStr = new string(chars.SelectMany(str => str) .OrderBy(c => Guid.NewGuid()) .Take(8).ToArray()); 

Here is a variant of Eric J’s solution, ie 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 < 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 < bytes.Length; i += 4) { result.Append(BitConverter.ToUInt32(bytes, i) % chars.Length); } return result.ToString(); } 

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); 

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 => Guid.NewGuid()) .Take(strLength) .Aggregate( new StringBuilder(), (builder, c) => 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 => 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.

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.

 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 => { index += random.Next(s.Length); if (index >= s.Length) index -= s.Length; return s[index]; }) .ToArray()); randomSymbolsIndex = index; return result; } } 

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); } 

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 < length; ++x) { sbuilder.Append((char)random.Next(33, 126)); } return sbuilder.ToString(); } } 

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. Espero eso ayude.

Intereting Posts