Jak mogę wygenerować losowe ciągi alfanumeryczne?

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

(Uwaga: użycie klasy Random sprawia, że nie nadaje się do niczego związanego z bezpieczeństwem, takiego jak tworzenie haseł lub tokenów. Użyj klasy RNGCryptoServiceProvider, jeśli potrzebujesz silnego generatora liczb losowych.)

Zaktualizowano na podstawie komentarzy. Oryginalna implementacja generowała a-h ~1,95% czasu, a pozostałe znaki ~1,56% czasu. Aktualizacja generuje wszystkie znaki ~1.61% czasu.

Framework SUPPORT - . Net Core 3 (i przyszłe platformy obsługujące. NET Standard 2.1 lub nowszy) zapewnia kryptograficznie poprawną metodę RandomNumberGenerator.GetInt32 () aby wygenerować losową liczbę całkowitą w żądanym zakresie.

W przeciwieństwie do niektórych alternatyw prezentowany, ten jest kryptograficznie dźwięczny .

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

Na podstawie dyskusji o alternatywach tutaj i zaktualizowane/zmodyfikowane na podstawie komentarzy poniżej.

Oto mała uprząż testowa, która demonstruje rozmieszczenie znaków w starym i zaktualizowanym wyjściu. Do głębokiej dyskusji analiza losowości , Sprawdź 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")}%");
            }
        }
    }
}

Rozwiązanie 1-największy "zakres" o najbardziej elastycznej długości

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

To rozwiązanie ma większy zakres niż użycie GUID, ponieważ GUID ma kilka stałych bitów, które są zawsze takie same i dlatego nie są losowe, na przykład 13 znak w hex jest zawsze "4" - przynajmniej w wersji 6 GUID.

To rozwiązanie pozwala również na wygenerowanie ciągu o dowolnej długości.

Rozwiązanie 2 - Jedna linia kodu-dobra do 22 znaków

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

You can ' t generowanie łańcuchów tak długo, jak rozwiązanie 1 i łańcuch nie ma tego samego zakresu ze względu na stałe bity w GUID ' ach, ale w wielu przypadkach to wystarczy.

Rozwiązanie 3-nieco mniej kodu

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

Głównie trzymanie tego tutaj dla celów historycznych. Używa nieco mniej kodu, co jest jednak kosztem posiadania mniejszego zakresu-ponieważ używa hex zamiast base64, potrzeba więcej znaków, aby reprezentować ten sam zakres w porównaniu z innymi rozwiązania.

Co oznacza większą szansę na kolizję-testowanie z 100 000 iteracji 8 ciągów znaków wygenerowało jeden duplikat.

Oto przykład, który ukradłem z przykładu sama Allena w Dot Net Perls

Jeśli potrzebujesz tylko 8 znaków, użyj Path.GetRandomFileName () w System.IO przestrzeń nazw. Sam mówi: "ścieżka.Metoda GetRandomFileName jest czasami lepsza, ponieważ używa RNGCryptoServiceProvider dla lepszej losowości. Jest ona jednak ograniczona do 11 losowych znaków."

GetRandomFileName zawsze zwraca 12-znakowy łańcuch znaków z kropką na 9-tym znaku. Więc będziesz trzeba usunąć kropkę (ponieważ nie jest to przypadkowe), a następnie wziąć 8 znaków z ciągu. Właściwie, możesz po prostu wziąć pierwsze 8 znaków i nie martwić się o okres.

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

PS: dzięki Sam

Główne cele mojego kodu to:

1. rozkład strun jest prawie jednolity (nie dbaj o drobne odchylenia, o ile są małe)
2. wyświetla ponad kilka miliardów łańcuchów dla każdego zestawu argumentów. Generowanie ciągu 8 znaków (~47 bitów entropii) jest bez znaczenia, jeśli twój PRNG generuje tylko 2 miliardy (31 bitów entropii) różnych wartości.
3. jest bezpieczny, ponieważ oczekuję, że ludzie będą używać tego do haseł lub innych zabezpieczeń żetony.

Pierwsza właściwość jest osiągana przez pobranie 64-bitowej wartości modulo wielkości alfabetu. W przypadku małych alfabetów (takich jak 62 znaki z pytania) prowadzi to do znikomego błędu. Drugą i trzecią właściwość uzyskuje się za pomocą RNGCryptoServiceProvider zamiast 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);
}

Najprostszy:

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

Możesz uzyskać lepszą wydajność, jeśli mocno zakodujesz tablicę znaków i polegasz na System.Random:

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

Jeśli kiedykolwiek martwisz się, że angielskie alfabety mogą się kiedyś zmienić i możesz stracić Biznes, możesz uniknąć twardego kodowania, ale powinieneś działać nieco gorzej (porównywalnie do podejścia 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<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);
}

Ostatnie dwa podejścia wyglądają lepiej, jeśli można zrobić z nich metodę rozszerzenia na instancji System.Random.

Tylko kilka porównań wydajności różnych odpowiedzi w tym wątku:

Methods & 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 => 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);
}

Wyniki

Testowane w LinqPad. Dla ciągu O rozmiarze 10, generuje:

• 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]

I liczby wydajności zmieniają się nieznacznie, bardzo czasami NonOptimized jest rzeczywiście szybszy, a czasami ForLoop i GenerateRandomString przełączają się, kto jest na prowadzeniu.

• LinqIsTheNewBlack (10000x) = 96762 (9.6762 ms)
• ForLoop (10000x) = 28970 kleszczy (2.897 ms)
• ForLoopNonOptimized (10000x) = 33336 kleszczy (3.3336 ms)
• Repeat (10000x) = 78547 kleszczy upłynęło (7.8547 ms)
• GenerateRandomString (10000x) = 27416 kleszczy (2.7416 ms)
• SecureFastRandom (10000x) = 13176 kleszczy (5ms) najniższa [inna maszyna]
• SecureFastRandom-NoCache (10000x) = 39541 kleszczy upłynął (17ms) najniższy [inna maszyna]

Jedna linijka kodu Membership.GeneratePassword() robi sztuczkę:)

Oto demo dla tego samego.

Kod napisany przez Erica J. jest dość niechlujny (jest całkiem jasne, że jest z 6 lat temu... pewnie dziś by tego kodu nie napisał), a są nawet pewne problemy.

W przeciwieństwie do niektórych przedstawionych alternatyw, ta jest kryptograficznie dźwięczna.

Nieprawda... Jest błąd w haśle (jak napisano w komentarzu), bcdefgh są trochę bardziej prawdopodobne niż pozostałe (a nie jest, ponieważ przez GetNonZeroBytes nie generuje bajtów o wartości zero, więc bias dla {[2] } jest przez niego Zbalansowany), więc nie jest to tak naprawdę dźwięk kryptograficzny.

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

Mój prosty, jednolinijkowy kod działa dla mnie:)

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

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

Aby rozszerzyć ten ciąg o dowolną długość

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

Używamy również niestandardowego łańcucha losowego, ale zaimplementowaliśmy go jako pomocnika łańcucha, dzięki czemu zapewnia on pewną elastyczność...

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

Użycie

var random = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Random();

Lub

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

Inną opcją może być użycie Linq i zagregowanie losowych znaków do stringbuildera.

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

Pytanie: Dlaczego mam marnować czas na używanie Enumerable.Range zamiast wpisywać "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;
    }
}

ODPOWIEDŹ: magiczne struny są złe. Czy ktoś zauważył, że nie ma "I" w moim sznurku na górze? Matka nauczyła mnie nie używać magicznych sznurków z tego właśnie powodu...

Uwaga 1: Jak mówi wielu innych, takich jak @dtb, nie używaj System.Random, jeśli potrzebujesz zabezpieczeń kryptograficznych. ..

Uwaga 2: Ta odpowiedź nie jest najskuteczniejsza ani najkrótsza, ale chciałem, aby przestrzeń oddziel odpowiedź od pytania. Celem mojej odpowiedzi jest bardziej Ostrzeżenie przed magicznymi strunami niż dostarczenie wymyślnej innowacyjnej odpowiedzi.

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

Po przejrzeniu innych odpowiedzi i rozważeniu komentarzy CodeInChaos, wraz z wciąż stronniczymi (choć mniej) odpowiedziami CodeInChaos, pomyślałem, że potrzebne jest ostateczne rozwiązanie Ultimate cut and paste . Więc aktualizując moją odpowiedź postanowiłem pójść na całość.

Aby uzyskać aktualną wersję tego kodu, odwiedź nowe repozytorium Hg na Bitbucket: https://bitbucket.org/merarischroeder/secureswiftrandom . polecam skopiować i wkleić kod z: https://bitbucket.org/merarischroeder/secureswiftrandom/src/6c14b874f34a3f6576b0213379ecdf0ffc7496ea/Code/Alivate.SolidSwiftRandom/SolidSwiftRandom.cs?at=default&fileviewer=file-view-default (upewnij się, że klikniesz przycisk Raw, aby ułatwić kopiowanie i upewnij się, że masz najnowszą wersję, myślę, że ten link idzie do konkretnej wersji kodu, a nie najnowszej).

Zaktualizowane uwagi:

1. odnoszące się do innych odpowiedzi - jeśli znasz długość wyjścia, nie potrzebujesz Stringbuildera, a gdy używasz ToCharArray, tworzy i wypełnia tablicę (nie musisz najpierw tworzyć pustej tablicy)
2. w odniesieniu do innych odpowiedzi-powinieneś używać NextBytes, a nie dostawać po jednym na raz dla wydajności
3. technicznie można przypiąć tablicę bajtów dla szybszego dostępu.. Zwykle warto, gdy iteracja więcej niż 6-8 razy nad tablicą bajtów. (Nie tutaj)
4. użycie RNGCryptoServiceProvider dla najlepszego randomness
Nie jest to jednak możliwe, ponieważ nie jest to możliwe, ponieważ nie jest to możliwe, ponieważ nie jest to możliwe, ponieważ nie jest to możliwe, ponieważ nie jest to możliwe.
5. / Align = "left" /

Rozwiązanie końcowe pytania:

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

Ale potrzebujesz mojej nowej (nieprzetestowanej) klasy:

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

Do historii - moje starsze rozwiązanie dla tej odpowiedzi, używane losowo obiekt:

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

Wydajność:

1. SecureFastRandom - pierwszy singel = ~9-33ms . Niezauważalne. trwa: 5ms (czasami dochodzi do 13ms) ponad 10 000 iteracji, z pojedynczą średnią iteracją= 1,5 mikrosekundy.. Uwaga: zazwyczaj wymaga 2, ale czasami do 8 odświeżeń pamięci podręcznej-zależy od tego, ile pojedynczych bajtów przekracza strefę bias
2. Random - pierwszy singiel = ~0-1ms. Niezauważalne. trwa: 5ms ponad 10 000 iteracji. Z pojedynczą średnią iteracją= .5 mikrosekund.. Z tą samą prędkością.

Zobacz też:

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

Te linki są innym podejściem. Buforowanie można było dodać do tej nowej bazy kodu, ale najważniejsze było badanie różnych podejść do usuwania uprzedzeń i porównywanie prędkości i zalet / wad.

Nieco czystsza wersja rozwiązania 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);

Twoje preferencje stylu mogą się różnić.

Straszne, wiem, ale nie mogłam się powstrzymać:

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

Szukałem bardziej konkretnej odpowiedzi, gdzie chcę kontrolować format losowego ciągu i natknąłem się na ten post. Na przykład: tablice rejestracyjne (samochodów) mają określony format (na kraj) i chciałem stworzyć losowe tablice rejestracyjne.
Postanowiłem napisać własną metodę rozszerzenia losowego dla tego. (ma to na celu ponowne użycie tego samego losowego obiektu, ponieważ można mieć podwojenie w scenariuszach wielowątkowych). I created a gist ( https://gist.github.com/SamVanhoutte/808845ca78b9c041e928), ale skopiuje również klasę extension tutaj:

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

Teraz w smaku jednowarstwowym.

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

Spróbuj połączyć dwie części: unikalną (sekwencję, licznik lub datę ) i losową

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 < 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)
    {
        const string chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //if you wish to make the 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;
    }
}

Testy:

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

Rozwiązanie bez użycia Random:

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

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

W przeciwieństwie do innych aplikacji, nie można ich używać w aplikacjach 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();
}

Jeśli wydajność ma znaczenie (zwłaszcza gdy długość jest wysoka):

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

Wiem, że to nie jest najlepszy sposób. Ale możesz spróbować tego.

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

Nie wiem, jak kryptograficznie brzmi to, ale jest bardziej czytelne i zwięzłe niż bardziej skomplikowane rozwiązania (imo) i powinno być bardziej "przypadkowe" niż rozwiązania oparte na System.Random.

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

Nie mogę się zdecydować, czy ta wersja, czy następna jest "ładniejsza" , ale dają dokładnie takie same wyniki:

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

Przyznaję, że nie jest zoptymalizowany pod kątem szybkości, więc jeśli kluczowe jest generowanie milionów losowych ciągów co sekundę, wypróbuj inny!

Uwaga: To rozwiązanie nie pozwala na powtórzenia symboli w alfabecie, a alfabet musi mieć równy lub większy rozmiar niż ciąg wyjściowy, co czyni to podejście mniej pożądanym w niektórych okolicznościach, wszystko zależy od Twojego przypadku użycia.

Zarówno dla krypto, jak i noncrypto, efektywnie:

private static readonly Random _random = new Random();

public static string GenerateRandomString(int length, string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890") =>
    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<byte[]> fillRandomBuffer, int length, char[] charset)
{
    if (length < 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 < length; i++)
        chars[i] = charset[BitConverter.ToUInt32(randomBuffer, i * 4) % maxIdx];

    return new string(chars);
}

Używając generatorów & LINQ. Nie jest to najszybsza opcja (zwłaszcza, że nie generuje wszystkich bajtów za jednym razem), ale całkiem zgrabna i rozszerzalna:

private static readonly Random _random = new Random();

public static string GenerateRandomString(int length, string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890") =>
    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<char> RandomChars(this Func<uint, IEnumerable<uint>> 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 => charset[r]);
}

public static Func<uint, IEnumerable<uint>> GetGenerator(this Random random)
{
    if (random is null)
        throw new ArgumentNullException(nameof(random));

    return GeneratorFunc_Inner;

    IEnumerable<uint> GeneratorFunc_Inner(uint maxValue)
    {
        if (maxValue > int.MaxValue)
            throw new ArgumentOutOfRangeException(nameof(maxValue));

        return Generator_Inner();

        IEnumerable<uint> Generator_Inner()
        {
            var randomBytes = new byte[4];
            while (true)
            {
                random.NextBytes(randomBytes);
                yield return BitConverter.ToUInt32(randomBytes, 0) % maxValue;
            }
        }
    }
}

public static Func<uint, IEnumerable<uint>> GetGenerator(this System.Security.Cryptography.RNGCryptoServiceProvider random)
{
    if (random is null)
        throw new ArgumentNullException(nameof(random));

    return Generator_Inner;

    IEnumerable<uint> Generator_Inner(uint maxValue)
    {
        var randomBytes = new byte[4];
        while (true)
        {
            random.GetBytes(randomBytes);
            yield return BitConverter.ToUInt32(randomBytes, 0) % maxValue;
        }
    }
}

Prostsza wersja wykorzystująca LINQ tylko dla ciągów nie-kryptograficznych:

private static readonly Random _random = new Random();

public static string RandomString(int length, string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890") =>
    new string(_random.GenerateChars(charset).Take(length).ToArray()); 

public static IEnumerable<char> 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 => charset[r]);
}

public static IEnumerable<int> Generator(this Random random, int maxValue)
{
    if (random is null) throw new ArgumentNullException(nameof(random));

    return Generator_Inner();

    IEnumerable<int> Generator_Inner() { while (true) yield return random.Next(maxValue); }
}

Jeśli twoje wartości nie są całkowicie losowe, ale w rzeczywistości mogą od czegoś zależeć - możesz obliczyć Skrót md5 lub sha1 tego "czegoś", a następnie obciąć go do dowolnej długości.

Można również wygenerować i obciąć 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;
    }
}

Oto mechanizm generowania losowego ciągu alfanumerycznego (używam go do generowania haseł i danych testowych) bez definiowania alfabetu i liczb,

CleanupBase64 usunie niezbędne części łańcucha i będzie dodawać losowo litery alfanumeryczne rekurencyjnie.

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

Istnieje jeden z pakietów awasome NuGet , które sprawiają, że jest to tak proste.

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

Jednym z dobrych przykładów jest Tutaj .