Generazione unica di stringhe casuali

Vorrei generare stringhe univoche casuali come quelle generate dalla libreria MSDN. ( Error Object ), per esempio. Dovrebbe essere generata una stringa come "t9zk6eay".

Usare Guid sarebbe un modo abbastanza buono, ma per ottenere qualcosa di simile al tuo esempio, probabilmente vorrai convertirlo in una stringa Base64:

    Guid g = Guid.NewGuid();
    string GuidString = Convert.ToBase64String(g.ToByteArray());
    GuidString = GuidString.Replace("=","");
    GuidString = GuidString.Replace("+","");

Mi sbarazzo di "=" e "+" per avvicinarmi un po 'al tuo esempio, altrimenti ottieni "==" alla fine della stringa e un "+" nel mezzo. Ecco una stringa di output di esempio:

"OZVV5TpP4U6wJthaCORZEQ"

Aggiornamento 2016/1/23

Se trovi utile questa risposta, potresti essere interessato a una semplice libreria di generazione di password (~ 500 SLOC) che ho pubblicato :

Install-Package MlkPwgen

Quindi puoi generare stringhe casuali proprio come nella risposta qui sotto:

var str = PasswordGenerator.Generate(length: 10, allowed: Sets.Alphanumerics);

Un vantaggio della libreria è che il codice è meglio scomposto in modo da poter utilizzare la casualità sicura per qualcosa di più della generazione di stringhe . Controlla il sito del progetto per maggiori dettagli.

Risposta originale

Poiché nessuno ha ancora fornito un codice sicuro, inserisco quanto segue nel caso qualcuno lo trovi utile.

string RandomString(int length, string allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") {
    if (length < 0) throw new ArgumentOutOfRangeException("length", "length cannot be less than zero.");
    if (string.IsNullOrEmpty(allowedChars)) throw new ArgumentException("allowedChars may not be empty.");

    const int byteSize = 0x100;
    var allowedCharSet = new HashSet<char>(allowedChars).ToArray();
    if (byteSize < allowedCharSet.Length) throw new ArgumentException(String.Format("allowedChars may contain no more than {0} characters.", byteSize));

    // Guid.NewGuid and System.Random are not particularly random. By using a
    // cryptographically-secure random number generator, the caller is always
    // protected, regardless of use.
    using (var rng = System.Security.Cryptography.RandomNumberGenerator.Create()) {
        var result = new StringBuilder();
        var buf = new byte[128];
        while (result.Length < length) {
            rng.GetBytes(buf);
            for (var i = 0; i < buf.Length && result.Length < length; ++i) {
                // Divide the byte into allowedCharSet-sized groups. If the
                // random value falls into the last group and the last group is
                // too small to choose from the entire allowedCharSet, ignore
                // the value in order to avoid biasing the result.
                var outOfRangeStart = byteSize - (byteSize % allowedCharSet.Length);
                if (outOfRangeStart <= buf[i]) continue;
                result.Append(allowedCharSet[buf[i] % allowedCharSet.Length]);
            }
        }
        return result.ToString();
    }
}

Grazie ad Ahmad per aver sottolineato come far funzionare il codice su .NET Core.

Vorrei avvertire che i GUID non sono numeri casuali . Non dovrebbero essere usati come base per generare qualcosa che ti aspetti essere totalmente casuale (vedi http://en.wikipedia.org/wiki/Globally_Unique_Identifier ):

La crittoanalisi del generatore di GUID WinAPI mostra che, poiché la sequenza dei GUID V4 è pseudo-casuale, dato lo stato iniziale si possono prevedere fino ai successivi 250.000 GUID restituiti dalla funzione UuidCreate. Questo è il motivo per cui i GUID non dovrebbero essere usati nella crittografia, ad esempio come chiavi casuali.

Usa invece il metodo C # Random. Qualcosa di simile ( codice trovato qui ):

private string RandomString(int size)
{
  StringBuilder builder = new StringBuilder();
  Random random = new Random();
  char ch ;
  for(int i=0; i<size; i++)
  {
    ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))) ;
    builder.Append(ch);
  }
  return builder.ToString();
}

I GUID vanno bene se vuoi qualcosa di unico (come un nome di file o una chiave univoci in un database), ma non sono adatti a qualcosa che vuoi che sia casuale (come una password o una chiave di crittografia). Quindi dipende dalla tua applicazione.

Modifica . Microsoft afferma che nemmeno Random è eccezionale ( http://msdn.microsoft.com/en-us/library/system.random(VS.71).aspx ):

Per generare un numero casuale crittograficamente sicuro adatto per la creazione di una password casuale, ad esempio, utilizzare una classe derivata da System.Security.Cryptography.RandomNumberGenerator come System.Security.Cryptography.RNGCryptoServiceProvider.

Ho semplificato la soluzione @Michael Kropats e ho realizzato una versione in stile LINQ.

string RandomString(int length, string alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
{       
    var outOfRange = byte.MaxValue + 1 - (byte.MaxValue + 1) % alphabet.Length;

    return string.Concat(
        Enumerable
            .Repeat(0, int.MaxValue)
            .Select(e => RandomByte())
            .Where(randomByte => randomByte < outOfRange)
            .Take(length)
            .Select(randomByte => alphabet[randomByte % alphabet.Length])
    );
}

byte RandomByte()
{
    using (var randomizationProvider = new RNGCryptoServiceProvider())
    {
        var randomBytes = new byte[1];
        randomizationProvider.GetBytes(randomBytes);
        return randomBytes.Single();
    }   
}

Non penso che siano davvero casuali, ma la mia ipotesi è che siano degli hash.

Ogni volta che ho bisogno di un identificatore casuale, di solito uso un GUID e lo converto nella sua rappresentazione "nuda":

Guid.NewGuid().ToString("n");

Prova la combinazione tra Guid e Time.Ticks

 var randomNumber = Convert.ToBase64String(Guid.NewGuid().ToByteArray()) + DateTime.Now.Ticks;
     randomNumber = System.Text.RegularExpressions.Regex.Replace(randomNumber, "[^0-9a-zA-Z]+", "");

Sono sorpreso del motivo per cui non è disponibile una soluzione CrytpoGraphic. GUID è unico ma non crittograficamente sicuro . Vedi questo Dotnet Fiddle.

var bytes = new byte[40]; // byte size
using (var crypto = new RNGCryptoServiceProvider())
  crypto.GetBytes(bytes);

var base64 = Convert.ToBase64String(bytes);
Console.WriteLine(base64);

Nel caso in cui desideri anteporre una guida:

var result = Guid.NewGuid().ToString("N") + base64;
Console.WriteLine(result);

Una stringa alfanumerica più pulita:

result = Regex.Replace(result,"[^A-Za-z0-9]","");
Console.WriteLine(result);

Soluzione di Michael Kropats in VB.net

Private Function RandomString(ByVal length As Integer, Optional ByVal allowedChars As String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") As String
    If length < 0 Then Throw New ArgumentOutOfRangeException("length", "length cannot be less than zero.")
    If String.IsNullOrEmpty(allowedChars) Then Throw New ArgumentException("allowedChars may not be empty.")


    Dim byteSize As Integer = 256
    Dim hash As HashSet(Of Char) = New HashSet(Of Char)(allowedChars)
    'Dim hash As HashSet(Of String) = New HashSet(Of String)(allowedChars)
    Dim allowedCharSet() = hash.ToArray

    If byteSize < allowedCharSet.Length Then Throw New ArgumentException(String.Format("allowedChars may contain no more than {0} characters.", byteSize))


    ' Guid.NewGuid and System.Random are not particularly random. By using a
    ' cryptographically-secure random number generator, the caller is always
    ' protected, regardless of use.
    Dim rng = New System.Security.Cryptography.RNGCryptoServiceProvider()
    Dim result = New System.Text.StringBuilder()
    Dim buf = New Byte(128) {}
    While result.Length < length
        rng.GetBytes(buf)
        Dim i
        For i = 0 To buf.Length - 1 Step +1
            If result.Length >= length Then Exit For
            ' Divide the byte into allowedCharSet-sized groups. If the
            ' random value falls into the last group and the last group is
            ' too small to choose from the entire allowedCharSet, ignore
            ' the value in order to avoid biasing the result.
            Dim outOfRangeStart = byteSize - (byteSize Mod allowedCharSet.Length)
            If outOfRangeStart <= buf(i) Then
                Continue For
            End If
            result.Append(allowedCharSet(buf(i) Mod allowedCharSet.Length))
        Next
    End While
    Return result.ToString()
End Function

Questo funziona perfettamente per me

    private string GeneratePasswordResetToken()
    {
        string token = Guid.NewGuid().ToString();
        var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(token);
        return Convert.ToBase64String(plainTextBytes);
    }

Questo è stato richiesto per varie lingue. Ecco una domanda sulle password che dovrebbero essere applicabili anche qui.

Se desideri utilizzare le stringhe per l'accorciamento dell'URL, avrai bisogno anche di un dizionario <> o di un controllo del database per vedere se un ID generato è già stato utilizzato.

Se vuoi stringhe alfanumeriche con caratteri minuscoli e maiuscoli ([a-zA-Z0-9]), puoi usare Convert.ToBase64String () per una soluzione rapida e semplice.

Per quanto riguarda l'unicità, controlla il problema del compleanno per calcolare la probabilità che una collisione sia data (A) la lunghezza delle stringhe generate e (B) il numero di stringhe generate.

Random random = new Random();

int outputLength = 10;
int byteLength = (int)Math.Ceiling(3f / 4f * outputLength); // Base64 uses 4 characters for every 3 bytes of data; so in random bytes we need only 3/4 of the desired length
byte[] randomBytes = new byte[byteLength];
string output;
do
{
    random.NextBytes(randomBytes); // Fill bytes with random data
    output = Convert.ToBase64String(randomBytes); // Convert to base64
    output = output.Substring(0, outputLength); // Truncate any superfluous characters and/or padding
} while (output.Contains('/') || output.Contains('+')); // Repeat if we contain non-alphanumeric characters (~25% chance if length=10; ~50% chance if length=20; ~35% chance if length=32)

• non sono sicuro che i collegamenti di Microsoft siano generati casualmente
• dare un'occhiata a new Guid (). ToString ()

Ottieni chiave univoca utilizzando il codice hash GUID

public static string GetUniqueKey(int length)
{
    string guidResult = string.Empty;

    while (guidResult.Length < length)
    {
        // Get the GUID.
        guidResult += Guid.NewGuid().ToString().GetHashCode().ToString("x");
    }

    // Make sure length is valid.
    if (length <= 0 || length > guidResult.Length)
        throw new ArgumentException("Length must be between 1 and " + guidResult.Length);

    // Return the first length bytes.
    return guidResult.Substring(0, length);
}