Come posso generare stringhe alfanumeriche casuali?

Come posso generare una stringa alfanumerica casuale di 8 caratteri in C #?

Ho sentito che LINQ è il nuovo nero, quindi ecco il mio tentativo di utilizzare 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: l'uso della Randomclasse lo rende inadatto per qualsiasi cosa relativa alla sicurezza , come la creazione di password o token. Utilizzare la RNGCryptoServiceProviderclasse se è necessario un forte generatore di numeri casuali.)

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

Non elegante come la soluzione Linq.

(Nota: l'uso della Randomclasse lo rende inadatto per qualsiasi cosa relativa alla sicurezza , come la creazione di password o token. Utilizzare la RNGCryptoServiceProviderclasse se è necessario un forte generatore di numeri casuali.)

AGGIORNATO in base ai commenti. L'implementazione originale ha generato circa l'1,95% delle volte e gli altri caratteri l'1,56% delle volte. L'aggiornamento genera tutti i caratteri ~ 1,61% delle volte.

SUPPORTO QUADRO - .NET Core 3 (e future piattaforme che supportano .NET Standard 2.1 o versioni successive) fornisce un metodo crittograficamente valido RandomNumberGenerator.GetInt32 () per generare un numero intero casuale nell'intervallo desiderato.

A differenza di alcune delle alternative presentate, questa è crittograficamente valida .

using System;
using System.Security.Cryptography;
using System.Text;

namespace UniqueKey
{
    public class KeyGenerator
    {
        internal static readonly char[] chars =
            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".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 < 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 =
                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".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();
        }
    }
}

Basato su una discussione di alternative qui e aggiornato / modificato in base ai commenti qui sotto.

Ecco un piccolo cablaggio di prova che dimostra la distribuzione dei caratteri nell'output precedente e aggiornato. Per una discussione approfondita sull'analisi della casualità , dai un'occhiata a 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("Original BIASED implementation");
            PerformTest(REPETITIONS, KEY_SIZE, KeyGenerator.GetUniqueKeyOriginal_BIASED);

            Console.WriteLine("Updated implementation");
            PerformTest(REPETITIONS, KEY_SIZE, KeyGenerator.GetUniqueKey);
            Console.ReadKey();
        }

        static void PerformTest(int repetitions, int keySize, Func<int, string> generator)
        {
            Dictionary<char, int> counts = new Dictionary<char, int>();
            foreach (var ch in UniqueKey.KeyGenerator.chars) counts.Add(ch, 0);

            for (int i = 0; i < 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($"{ch}: {(100.0 * counts[ch] / totalChars).ToString("#.000")}%");
            }
        }
    }
}

Soluzione 1: la "gamma" più ampia con la lunghezza più flessibile

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

Questa soluzione ha una portata maggiore rispetto all'utilizzo di un GUID perché un GUID ha un paio di bit fissi che sono sempre gli stessi e quindi non casuali, ad esempio il carattere 13 in esadecimale è sempre "4" - almeno in un GUID versione 6.

Questa soluzione consente anche di generare una stringa di qualsiasi lunghezza.

Soluzione 2 - Una riga di codice - valida per un massimo di 22 caratteri

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

Non è possibile generare stringhe fintanto che la Soluzione 1 e la stringa non hanno lo stesso intervallo a causa di bit fissi nei GUID, ma in molti casi questo farà il lavoro.

Soluzione 3 - Codice leggermente inferiore

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

Principalmente conservarlo qui per scopi storici. Usa un po 'meno codice, che però ha il costo di avere un intervallo minore - poiché usa hex invece di base64 ci vogliono più caratteri per rappresentare lo stesso intervallo rispetto alle altre soluzioni.

Ciò significa maggiori possibilità di collisione: testarlo con 100.000 iterazioni di 8 stringhe di caratteri ha generato un duplicato.

Ecco un esempio che ho rubato dall'esempio di Sam Allen a Dot Net Perls

Se sono necessari solo 8 caratteri, utilizzare Path.GetRandomFileName () nello spazio dei nomi System.IO. Sam afferma che l'uso del metodo "Path.GetRandomFileName qui è talvolta superiore, perché utilizza RNGCryptoServiceProvider per una migliore casualità. Tuttavia, è limitato a 11 caratteri casuali."

GetRandomFileName restituisce sempre una stringa di 12 caratteri con un punto al nono carattere. Quindi dovrai rimuovere il punto (dato che non è casuale) e quindi prendere 8 caratteri dalla stringa. In realtà, potresti prendere solo i primi 8 personaggi e non preoccuparti del periodo.

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

PS: grazie Sam

Gli obiettivi principali del mio codice sono:

1. La distribuzione delle stringhe è quasi uniforme (non preoccuparti delle deviazioni minori, purché siano piccole)
2. Produce più di qualche miliardo di stringhe per ogni set di argomenti. Generare una stringa di 8 caratteri (~ 47 bit di entropia) non ha senso se il tuo PRNG genera solo 2 miliardi (31 bit di entropia) di valori diversi.
3. È sicuro, poiché mi aspetto che le persone lo utilizzino per password o altri token di sicurezza.

La prima proprietà si ottiene prendendo un valore di 64 bit modulo la dimensione dell'alfabeto. Per i piccoli alfabeti (come i 62 caratteri della domanda) questo porta a una distorsione trascurabile. La seconda e la terza proprietà si ottengono usando RNGCryptoServiceProviderinvece di 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<char> 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];
    var result = new char[length];
    using (var cryptoProvider = new RNGCryptoServiceProvider())
    {
        cryptoProvider.GetBytes(bytes);
    }
    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);
}

Il più semplice:

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

È possibile ottenere prestazioni migliori se si codifica il array di caratteri e si fa affidamento su System.Random:

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

Se mai ti preoccupi, gli alfabeti inglesi possono cambiare in qualche momento e potresti perdere affari, quindi puoi evitare la codifica rigida, ma dovresti comportarti leggermente peggio (paragonabile Path.GetRandomFileNameall'approccio)

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

Gli ultimi due approcci sembrano migliori se puoi renderli un metodo di estensione su System.Randomistanza.

Solo alcuni confronti delle prestazioni delle varie risposte in questo thread:

Metodi e configurazione

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

risultati

Testato su LinqPad. Per stringhe di 10, genera:

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

E i numeri di spettacolo tendono a variare un po ', molto di tanto in tanto NonOptimizedè effettivamente più veloce, e qualche volta ForLoope GenerateRandomStringpassare chi è in testa.

• LinqIsTheNewBlack (10000x) = 96762 tick scaduti (9.6762 ms)
• ForLoop (10000x) = 28970 tick scaduti (2.897 ms)
• ForLoopNonOptimized (10000x) = 33336 tick scaduti (3.3336 ms)
• Ripeti (10000x) = 78547 tick scaduti (7.8547 ms)
• GenerateRandomString (10000x) = 27416 tick scaduti (2.7416 ms)
• SecureFastRandom (10000x) = 13176 tick scaduti (5ms) più basso [Macchina diversa]
• SecureFastRandom-NoCache (10000x) = 39541 tick scaduti (17ms) più basso [Macchina diversa]

Una riga di codice Membership.GeneratePassword()fa il trucco :)

Ecco una demo per lo stesso.

Il codice scritto da Eric J. è piuttosto sciatto (è abbastanza chiaro che è di 6 anni fa ... probabilmente non scriverà quel codice oggi), e ci sono anche alcuni problemi.

A differenza di alcune delle alternative presentate, questa è crittograficamente valida.

Non vero ... C'è un bias nella password (come scritto in un commento), bcdefghsono un po 'più probabili degli altri (il anon è perché dal GetNonZeroBytesnon sta generando byte con un valore pari a zero, quindi il bias perché aè bilanciato da esso), quindi non è veramente crittograficamente valido.

Questo dovrebbe correggere tutti i problemi.

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

Usiamo anche stringhe personalizzate casuali ma abbiamo implementato come aiuto di una stringa, quindi offre una certa flessibilità ...

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

Il mio semplice codice a una riga funziona per me :)

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

Response.Write(random.ToUpper());
Response.Write(random.ToLower());

Per espandere su questo per qualsiasi stringa di lunghezza

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

Un'altra opzione potrebbe essere quella di utilizzare Linq e aggregare caratteri casuali in un costruttore di stringhe.

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

Domanda: Perché dovrei perdere tempo usando Enumerable.Rangeinvece di digitare "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<char> getAvailableRandomCharacters(bool includeLowerCase)
    {
        var integers = Enumerable.Empty<int>();
        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<char> 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;
    }
}

Risposta: le stringhe magiche sono CATTIVE. Qualcuno ha notato che non c'era " I" nella mia stringa in alto? Mia madre mi ha insegnato a non usare archi magici proprio per questo motivo ...

nb 1: come molti altri come hanno detto @dtb, non usare System.Randomse hai bisogno di sicurezza crittografica ...

nb 2: questa risposta non è la più efficiente o la più breve, ma volevo che lo spazio separasse la risposta dalla domanda. Lo scopo della mia risposta è più di mettere in guardia contro le corde magiche che di fornire una risposta innovativa di fantasia.

Una versione leggermente più pulita della soluzione di 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);

Le tue preferenze di stile possono variare.

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

Dopo aver esaminato le altre risposte e considerato i commenti di CodeInChaos, insieme a CodeInChaos ancora di parte (anche se meno), ho pensato che fosse necessaria una soluzione definitiva per tagliare e incollare . Quindi, aggiornando la mia risposta, ho deciso di fare tutto.

Per una versione aggiornata di questo codice, visitare il nuovo repository Hg su Bitbucket: https://bitbucket.org/merarischroeder/secureswiftrandom . Vi consiglio di copiare e incollare il codice da: https://bitbucket.org/merarischroeder/secureswiftrandom/src/6c14b874f34a3f6576b0213379ecdf0ffc7496ea/Code/Alivate.SolidSwiftRandom/SolidSwiftRandom.cs?at=default&fileviewer=file-view-default (assicuratevi di clic il pulsante Raw per semplificare la copia e assicurarsi di disporre dell'ultima versione, penso che questo link vada a una versione specifica del codice, non all'ultima).

Note aggiornate:

1. Relativo ad altre risposte - Se conosci la lunghezza dell'output, non hai bisogno di StringBuilder e quando usi ToCharArray, questo crea e riempie l'array (non devi prima creare un array vuoto)
2. In relazione ad alcune altre risposte - Dovresti usare NextBytes, invece di ottenerne uno alla volta per le prestazioni
3. Tecnicamente potresti bloccare l'array di byte per un accesso più veloce .. di solito ne vale la pena quando esegui l'iterazione più di 6-8 volte su un array di byte. (Non fatto qui)
4. Uso di RNGCryptoServiceProvider per la migliore casualità
5. Uso della memorizzazione nella cache di un buffer da 1 MB di dati casuali - il benchmarking mostra che la velocità di accesso ai singoli byte memorizzata nella cache è ~ 1000x più veloce - prendendo 9ms su 1 MB contro 989ms per la cache.
6. Rifiuto ottimizzato della zona di polarizzazione all'interno della mia nuova classe.

Termina la soluzione alla domanda:

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

Ma hai bisogno della mia nuova classe (non testata):

/// <summary>
/// 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
/// </summary>
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;

    /// <summary>
    /// Static direct uncached access to the RNGCryptoServiceProvider GetBytes function
    /// </summary>
    /// <param name="buffer"></param>
    public static void DirectGetBytes(byte[] buffer)
    {
        using (var r = new RNGCryptoServiceProvider())
        {
            r.GetBytes(buffer);
        }
    }

    /// <summary>
    /// Main expected method to be called by user. Underlying random data is cached from RNGCryptoServiceProvider for best performance
    /// </summary>
    /// <param name="buffer"></param>
    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;
        }
    }

    /// <summary>
    /// Return a single byte from the cache of random data.
    /// </summary>
    /// <returns></returns>
    public static byte GetByte()
    {
        lock (byteCache)
        {
            return UnsafeGetByte();
        }
    }

    /// <summary>
    /// Shared with public GetByte and GetBytesWithMax, and not locked to reduce lock/unlocking in loops. Must be called within lock of byteCache.
    /// </summary>
    /// <returns></returns>
    static byte UnsafeGetByte()
    {
        if (1 > remaining)
        {
            DirectGetBytes(byteCache);
            lastPosition = 0;
            remaining = byteCache.Length;
        }

        lastPosition++;
        remaining--;
        return byteCache[lastPosition - 1];
    }

    /// <summary>
    /// 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.
    /// </summary>
    /// <param name="buffer"></param>
    /// <param name="max"></param>
    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);
            }
        }
    }

    /// <summary>
    /// Checks buffer for bytes equal and above max. Must be called within lock of byteCache.
    /// </summary>
    /// <param name="buffer"></param>
    /// <param name="max"></param>
    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
        }
    }
}

Per la cronologia: la mia soluzione precedente per questa risposta, ha usato l'oggetto Casuale:

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

Prestazione:

1. SecureFastRandom - Prima esecuzione singola = ~ 9-33ms . Impercettibile. In corso : 5 ms (a volte arriva fino a 13 ms) su 10.000 iterazioni, con una singola iterazione media = 1,5 microsecondi. . Nota: richiede generalmente 2, ma occasionalmente fino a 8 aggiornamenti della cache - dipende da quanti singoli byte superano la zona di polarizzazione
2. Casuale - Prima corsa singola = ~ 0-1ms . Impercettibile. In corso : 5 ms oltre 10.000 iterazioni. Con una singola iterazione media = 0,5 microsecondi. . Circa alla stessa velocità.

Controlla anche:

• https://bitbucket.org/merarischroeder/number-range-with-no-bias/src
• https://stackoverflow.com/a/45118325/887092

Questi collegamenti sono un altro approccio. Il buffering potrebbe essere aggiunto a questa nuova base di codice, ma la cosa più importante è stata esplorare diversi approcci per rimuovere i pregiudizi e confrontare i parametri di velocità e vantaggi / svantaggi.

Orribile, lo so, ma non riuscivo a trattenermi:

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

Stavo cercando una risposta più specifica, in cui desidero controllare il formato della stringa casuale e mi sono imbattuto in questo post. Ad esempio: le targhe (delle automobili) hanno un formato specifico (per paese) e volevo creare targhe casuali.
Ho deciso di scrivere il mio metodo di estensione di Random per questo. (questo per riutilizzare lo stesso oggetto Casuale, in quanto si potrebbero avere doppi in scenari multi-threading). Ho creato una sintesi ( https://gist.github.com/SamVanhoutte/808845ca78b9c041e928 ), ma copierò anche la classe di estensione qui:

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

Ora nel gusto di una linea.

private string RandomName()
{
        return new string(
            Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 13)
                .Select(s =>
                {
                    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());
}

Prova a combinare due parti: unica (sequenza, contatore o data) e casuale

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 || // A-Z
                code > 97 && code < 122   // a-z
                )
            {
                result += Convert.ToChar(code);
            }
        }

        return result;
    }

    private static string ConvertToBase(long num, int nbase = 36)
    {
        var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //if you wish make algorithm 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;
    }
}

test:

[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())
    }

Una soluzione senza usare Random:

var chars = Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 8);

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

Ecco una variante della soluzione di Eric J, ovvero crittograficamente sana, per WinRT (app di Windows Store):

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

Se le prestazioni contano (soprattutto quando la lunghezza è alta):

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

So che questo non è il modo migliore. Ma puoi provare questo.

string str = Path.GetRandomFileName(); //This method returns a random file name of 11 characters
str = str.Replace(".","");
Console.WriteLine("Random string: " + str);

Non so quanto sia crittograficamente valido, ma è più leggibile e conciso delle soluzioni più intricate di gran lunga (imo), e dovrebbe essere più "casuale" di System.Randomsoluzioni basate su.

return alphabet
    .OrderBy(c => Guid.NewGuid())
    .Take(strLength)
    .Aggregate(
        new StringBuilder(),
        (builder, c) => builder.Append(c))
    .ToString();

Non riesco a decidere se penso che questa versione o la successiva siano "più belle", ma danno esattamente gli stessi risultati:

return new string(alphabet
    .OrderBy(o => Guid.NewGuid())
    .Take(strLength)
    .ToArray());

Certo, non è ottimizzato per la velocità, quindi se è fondamentale generare milioni di stringhe casuali ogni secondo, provane un'altra!

NOTA: questa soluzione non consente la ripetizione di simboli nell'alfabeto e l'alfabeto DEVE avere dimensioni uguali o maggiori della stringa di output, rendendo questo approccio meno desiderabile in alcune circostanze, tutto dipende dal caso d'uso.

Se i tuoi valori non sono completamente casuali, ma in realtà possono dipendere da qualcosa - puoi calcolare un hash md5 o sha1 di quel "qualcosa" e poi troncarlo per la lunghezza che desideri.

Inoltre puoi generare e troncare un 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;
    }
}

Ecco un meccanismo per generare una stringa alfanumerica casuale (la utilizzo per generare password e dati di test) senza definire l'alfabeto e i numeri,

CleanupBase64 rimuoverà le parti necessarie nella stringa e continuerà ad aggiungere lettere alfanumeriche casuali in modo ricorsivo.

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

C'è uno dei fantastici pacchetti nuget che lo rendono così semplice.

var myObject = new Faker<MyObject>()
.RuleFor(p => p.MyAlphaNumericProperty, f => f.Random.AlphaNumeric(/*lenght*/ 7))
.Generate();

Uno dei buoni esempi è qui .

non sicuro al 100%, dato che non ho testato OGNI opzione qui, ma di quelle che ho testato, questa è la più veloce. cronometrato con cronometro e ha mostrato 9-10 tick quindi se la velocità è più importante della sicurezza, prova questo:

 private static Random random = new Random(); 
 public static string Random(int length)
     {   
          var stringChars = new char[length];

          for (int i = 0; i < length; i++)
              {
                  stringChars[i] = (char)random.Next(0x30, 0x7a);                  
                  return new string(stringChars);
              }
     }