Wie kann ich zufällige alphanumerische Zeichenfolgen generieren?

967

Wie kann ich eine zufällige 8-stellige alphanumerische Zeichenfolge in C # generieren?

KingNestor
quelle
2
Welche Einschränkungen haben Sie gegebenenfalls für den Zeichensatz? Nur englischsprachige Zeichen und 0-9? Gemischter Fall?
Eric J.
9
Beachten Sie, dass Sie KEINE auf der RandomKlasse basierende Methode verwenden sollten , um Kennwörter zu generieren. Die Aussaat Randomhat eine sehr geringe Entropie, daher ist sie nicht wirklich sicher. Verwenden Sie ein kryptografisches PRNG für Kennwörter.
CodesInChaos
2
Es wäre schön, die Sprachlokalisierung in diese Frage aufzunehmen. Vor allem, wenn Ihre GUI für Chinesisch oder Bulgarisch sorgen muss!
Peter Jamsmenson
15
Etwas mit so vielen positiven Stimmen und so vielen hochwertigen Antworten verdient es nicht, als geschlossen markiert zu werden. Ich stimme dafür, dass es wiedereröffnet wird.
John Coleman

Antworten:

1684

Ich habe gehört, dass LINQ das neue Schwarz ist. Hier ist mein Versuch, LINQ zu verwenden:

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

(Hinweis: Die Verwendung der RandomKlasse macht dies für sicherheitsrelevante Zwecke wie das Erstellen von Kennwörtern oder Token ungeeignet . Verwenden Sie die RNGCryptoServiceProviderKlasse, wenn Sie einen starken Zufallszahlengenerator benötigen.)

dtb
quelle
24
@Alex: Ich habe ein paar schnelle Tests durchgeführt und es scheint ziemlich linear zu skalieren, wenn längere Zeichenfolgen generiert werden (solange tatsächlich genügend Speicher verfügbar ist). Trotzdem war Dan Rigbys Antwort in jedem Test fast doppelt so schnell wie diese.
LukeH
6
Gut. Wenn Ihr Kriterium ist, dass es linq verwendet und dass es eine miese Code-Erzählung hat, dann sind es definitiv die Knie der Biene. Sowohl die Codeerzählung als auch der tatsächliche Ausführungspfad sind eher ineffizient und indirekt. Versteh mich nicht falsch, ich bin ein riesiger Code-Hipster (ich liebe Python), aber das ist so ziemlich eine Rube Goldberg-Maschine.
Eremzeit
5
Während dies die Frage technisch beantwortet, ist die Ausgabe sehr irreführend. Das Generieren von 8 zufälligen Zeichen klingt so, als ob es sehr viele Ergebnisse geben kann, während dies bestenfalls 2 Milliarden verschiedene Ergebnisse liefert. Und in der Praxis noch weniger. Sie sollten auch eine BIG FAT-Warnung hinzufügen, um diese nicht für sicherheitsrelevante Zwecke zu verwenden.
CodesInChaos
41
@xaisoft: Kleinbuchstaben bleiben als Übung für den Leser.
dtb
15
Die folgende Zeile ist speichereffizienter (und damit zeitsparender) als die angegebenereturn new string(Enumerable.Range(1, length).Select(_ => chars[random.Next(chars.Length)]).ToArray());
Tyson Williams
376
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);

Nicht so elegant wie die Linq-Lösung.

(Hinweis: Die Verwendung der RandomKlasse macht dies für sicherheitsrelevante Zwecke wie das Erstellen von Kennwörtern oder Token ungeeignet . Verwenden Sie die RNGCryptoServiceProviderKlasse, wenn Sie einen starken Zufallszahlengenerator benötigen.)

Dan Rigby
quelle
4
@Alex: Dies ist nicht die absolut schnellste Antwort, aber es ist die schnellste "echte" Antwort (dh von denen, die die Kontrolle über die verwendeten Zeichen und die Länge der Zeichenfolge ermöglichen).
LukeH
2
@Alex: Die GetRandomFileNameLösung von Adam Porad ist schneller, erlaubt jedoch keine Kontrolle über die verwendeten Zeichen und die maximal mögliche Länge beträgt 11 Zeichen. Douglas ' GuidLösung ist blitzschnell, aber die Zeichen sind auf A-F0-9 beschränkt und die maximal mögliche Länge beträgt 32 Zeichen.
LukeH
1
@Adam: Ja, Sie könnten das Ergebnis mehrerer Aufrufe zusammenfassen, GetRandomFileNameaber dann (a) würden Sie Ihren Leistungsvorteil verlieren und (b) Ihr Code würde komplizierter werden.
LukeH
2
@xaisoft erstellt Ihre Instanz des Random () -Objekts außerhalb Ihrer Schleife. Wenn Sie in einem kurzen Intervall viele Instanzen von Random () erstellen, gibt der Aufruf von .Next () den gleichen Wert zurück wie Random () einen zeitbasierten Startwert verwendet.
Dan Rigby
2
@xaisoft Verwenden Sie diese Antwort nicht für sicherheitskritische Elemente wie Kennwörter. System.Randomist nicht für die Sicherheit geeignet.
CodesInChaos
333

AKTUALISIERT basierend auf Kommentaren. Die ursprüngliche Implementierung erzeugte in ~ 1,95% der Fälle und die verbleibenden Zeichen in ~ 1,56% der Fälle. Das Update generiert in ~ 1,61% der Fälle alle Zeichen.

FRAMEWORK SUPPORT - .NET Core 3 (und zukünftige Plattformen, die .NET Standard 2.1 oder höher unterstützen) bietet eine kryptografisch fundierte Methode RandomNumberGenerator.GetInt32 () , um eine zufällige Ganzzahl innerhalb eines gewünschten Bereichs zu generieren.

Im Gegensatz zu einigen der vorgestellten Alternativen ist diese kryptografisch fundiert .

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

Basierend auf einer Diskussion der Alternativen hier und aktualisiert / modifiziert basierend auf den Kommentaren unten.

Hier ist ein kleines Testkabel, das die Verteilung der Zeichen in der alten und aktualisierten Ausgabe demonstriert. Eine ausführliche Beschreibung der Analyse der Zufälligkeit finden Sie unter 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")}%");
            }
        }
    }
}
Eric J.
quelle
11
Dies scheint mir die richtige Herangehensweise zu sein - zufällige Passwörter, Salze, Entropie usw. sollten nicht mit Random () generiert werden, das auf Geschwindigkeit optimiert ist und reproduzierbare Zahlenfolgen generiert. RNGCryptoServiceProvider.GetNonZeroBytes () erzeugt dagegen wilde Folgen von Zahlen, die NICHT reproduzierbar sind.
mindplay.dk
25
Die Buchstaben sind leicht voreingenommen (255% 62! = 0). Trotz dieses kleinen Fehlers ist es hier bei weitem die beste Lösung.
CodesInChaos
13
Beachten Sie, dass dies nicht sinnvoll ist, wenn Sie eine kryptostarke, unvoreingenommene Zufälligkeit wünschen. (Und wenn Sie das nicht wollen, warum dann überhaupt verwenden RNGCSP?) Die Verwendung von Mod zum Indizieren in das charsArray bedeutet, dass Sie eine voreingenommene Ausgabe erhalten, es sei denn, chars.Lengthes handelt sich um einen Divisor von 256.
LukeH
15
Eine Möglichkeit, die Vorspannung stark zu reduzieren, besteht darin, 4*maxSizezufällige Bytes anzufordern und dann zu verwenden (UInt32)(BitConverter.ToInt32(data,4*i)% chars.Length. Ich würde auch GetBytesanstelle von verwenden GetNonZeroBytes. Und schließlich können Sie den ersten Anruf an entfernen GetNonZeroBytes. Sie verwenden das Ergebnis nicht.
CodesInChaos
14
Unterhaltsame Tatsache: AZ az 0-9 besteht aus 62 Zeichen. Die Leute weisen auf Buchstabenbias hin, weil 256% 62! = 0. Die Video-IDs von YouTube sind AZ az 0-9 sowie "-" und "_", wodurch 64 mögliche Zeichen erzeugt werden, die sich gleichmäßig in 256 teilen. Zufall? Ich denke nicht! :)
qJake
200

Lösung 1 - größter Bereich mit der flexibelsten Länge

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

Diese Lösung hat mehr Reichweite als die Verwendung einer GUID, da eine GUID einige feste Bits hat, die immer gleich und daher nicht zufällig sind. Beispielsweise ist das hexadezimale 13-Zeichen immer "4" - zumindest in einer GUID der Version 6.

Mit dieser Lösung können Sie auch eine Zeichenfolge beliebiger Länge generieren.

Lösung 2 - Eine Codezeile - gut für bis zu 22 Zeichen

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

Sie können keine Zeichenfolgen generieren, solange Lösung 1 vorhanden ist und die Zeichenfolge aufgrund fester Bits in den GUIDs nicht denselben Bereich haben. In vielen Fällen reicht dies jedoch aus.

Lösung 3 - Etwas weniger Code

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

Meistens hier für historische Zwecke. Es wird etwas weniger Code verwendet, was jedoch die Kosten für eine geringere Reichweite mit sich bringt. Da Hex anstelle von base64 verwendet wird, sind im Vergleich zu den anderen Lösungen mehr Zeichen erforderlich, um denselben Bereich darzustellen.

Dies bedeutet eine höhere Kollisionswahrscheinlichkeit. Durch Testen mit 100.000 Iterationen von 8 Zeichenfolgen wurde ein Duplikat generiert.

Douglas
quelle
22
Sie haben tatsächlich ein Duplikat erstellt? Überraschend bei 5.316.911.983.139.663.491.615.228.241.121.400.000 möglichen Kombinationen von GUIDs.
Alex
73
@Alex: Er verkürzt die GUID auf 8 Zeichen, daher ist die Wahrscheinlichkeit von Kollisionen viel höher als die von GUIDs.
dtb
23
Niemand außer Nerds kann das schätzen :) Ja, Sie haben absolut Recht, das Limit von 8 Zeichen macht einen Unterschied.
Alex
31
Guid.NewGuid (). ToString ("n") hält die Striche fern, es ist kein Aufruf von Replace () erforderlich. Es sollte jedoch erwähnt werden, dass die GUIDs nur 0-9 und AF sind. Die Anzahl der Kombinationen ist "gut genug", aber bei weitem nicht annähernd das, was eine echte alphanumerische Zufallszeichenfolge zulässt. Die Wahrscheinlichkeit einer Kollision beträgt 1: 4,294,967,296 - das gleiche wie bei einer zufälligen 32-Bit-Ganzzahl.
richardtallent
32
1) GUIDs sind eindeutig und nicht zufällig. Während aktuelle Windows-Versionen V4-GUIDs generieren, die tatsächlich zufällig sind, ist dies nicht garantiert. Zum Beispiel verwendeten ältere Windows-Versionen V1-GUIDs, bei denen dies fehlschlagen könnte. 2) Die Verwendung von Hex-Zeichen verringert die Qualität der zufälligen Zeichenfolge erheblich. Von 47 bis 32 Bit. 3) Menschen unterschätzen die Kollisionswahrscheinlichkeit, da sie sie für einzelne Paare angeben. Wenn Sie 100.000 32-Bit-Werte generieren, haben Sie wahrscheinlich eine Kollision zwischen ihnen. Siehe Geburtstagsproblem.
CodesInChaos
72

Hier ist ein Beispiel, das ich aus dem Beispiel von Sam Allen bei gestohlen habe Dot Net Perls

Wenn Sie nur 8 Zeichen benötigen, verwenden Sie Path.GetRandomFileName () im System.IO-Namespace. Sam sagt, dass die Verwendung der "Path.GetRandomFileName-Methode hier manchmal überlegen ist, da sie RNGCryptoServiceProvider für eine bessere Zufälligkeit verwendet. Sie ist jedoch auf 11 zufällige Zeichen beschränkt."

GetRandomFileName gibt immer eine 12-stellige Zeichenfolge mit einem Punkt am 9. Zeichen zurück. Sie müssen also den Punkt entfernen (da dies nicht zufällig ist) und dann 8 Zeichen aus der Zeichenfolge entfernen. Eigentlich könnte man einfach die ersten 8 Zeichen nehmen und sich keine Sorgen um den Zeitraum machen.

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

PS: Danke Sam

Adam Porad
quelle
27
Das funktioniert gut. Ich habe 100.000 Iterationen durchlaufen und hatte nie einen doppelten Namen. Ich habe jedoch einige vulgäre Wörter gefunden (auf Englisch). Ich hätte nicht einmal daran gedacht, außer dass einer der ersten auf der Liste F *** enthielt. Nur ein Hinweis, wenn Sie dies für etwas verwenden, das der Benutzer sehen wird.
Techturtle
3
@techturtle Danke für die Warnung. Ich nehme an, es besteht ein Risiko für vulgäre Wörter bei jeder zufälligen Zeichenfolgengenerierung, bei der alle Buchstaben des Alphabets verwendet werden.
Adam Porad
nett und einfach, aber nicht gut für lange Saiten ...
stimme
Diese Methode scheint nur alphanumerische Zeichenfolgen in Kleinbuchstaben zurückzugeben.
Jaybro
2
Es gibt von Zeit zu Zeit vulgäre Worte, aber wenn Sie dies lange genug laufen lassen, schreibt es schließlich Shakespeare. (Nur ein paar Leben des Universums. :)
Slothario
38

Die Hauptziele meines Codes sind:

  1. Die Verteilung der Zeichenfolgen ist nahezu gleichmäßig (kleinere Abweichungen sind nicht wichtig, solange sie klein sind).
  2. Es werden mehr als ein paar Milliarden Zeichenfolgen für jeden Argumentsatz ausgegeben. Das Generieren einer 8-Zeichenfolge (~ 47 Bit Entropie) ist bedeutungslos, wenn Ihr PRNG nur 2 Milliarden (31 Bit Entropie) verschiedene Werte generiert.
  3. Es ist sicher, da ich erwarte, dass Leute dies für Passwörter oder andere Sicherheitstoken verwenden.

Die erste Eigenschaft wird erreicht, indem ein 64-Bit-Wert modulo der Alphabetgröße verwendet wird. Bei kleinen Alphabeten (wie den 62 Zeichen aus der Frage) führt dies zu einer vernachlässigbaren Verzerrung. Die zweite und dritte Eigenschaft werden durch Verwendung von RNGCryptoServiceProvideranstelle von erreicht 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);
}
CodesInChaos
quelle
1
Es gibt keinen Schnittpunkt mit 64 x Z und Math.Pow (2, Y). Wenn Sie also größere Zahlen erstellen, wird die Verzerrung verringert, aber nicht beseitigt. Ich habe meine Antwort unten aktualisiert. Mein Ansatz war es, zufällige Eingaben zu verwerfen und durch einen anderen Wert zu ersetzen.
Todd
@Todd Ich weiß, dass es die Verzerrung nicht beseitigt, aber ich habe die Einfachheit dieser Lösung der Beseitigung einer praktisch irrelevanten Verzerrung vorgezogen.
CodesInChaos
Ich stimme zu, dass dies in den meisten Fällen wahrscheinlich praktisch irrelevant ist. Aber jetzt habe ich meine so aktualisiert, dass sie sowohl so schnell wie zufällig als auch etwas sicherer als Ihre ist. Alles Open Source für alle zum Teilen. Ja, ich habe viel zu viel Zeit damit verschwendet ...
Todd
Wenn wir einen RNG-Anbieter verwenden, haben wir dann eine Möglichkeit, theoretische Verzerrungen zu vermeiden? Ich bin mir nicht sicher ... Wenn Todd meint, wie er zusätzliche Zufallszahlen generiert (wenn wir uns in der Bias-Zone befinden), kann dies eine falsche Annahme sein. RNG hat eine nahezu lineare Verteilung aller generierten Werte im Durchschnitt. Dies bedeutet jedoch nicht, dass keine lokale Korrelation zwischen den generierten Bytes besteht. Ein zusätzliches Byte nur für die Vorspannungszone kann uns also immer noch eine gewisse Vorspannung geben, jedoch aus einem anderen Grund. Höchstwahrscheinlich wird diese Tendenz sehr gering sein. ABER in diesem Fall ist das Erhöhen der insgesamt erzeugten Bytes einfacher.
Maxim
1
@Maxim Sie können die Zurückweisung verwenden, um die Verzerrung vollständig zu beseitigen (vorausgesetzt, der zugrunde liegende Generator ist vollkommen zufällig). Im Gegenzug kann der Code beliebig lang sein (mit exponentiell geringer Wahrscheinlichkeit).
CodesInChaos
32

Das einfachste:

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

Sie können eine bessere Leistung erzielen, wenn Sie das char-Array hart codieren und sich auf Folgendes verlassen System.Random:

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

Wenn Sie sich jemals Sorgen machen, dass sich die englischen Alphabete irgendwann ändern können und Sie möglicherweise das Geschäft verlieren, können Sie eine harte Codierung vermeiden, sollten jedoch eine etwas schlechtere Leistung erbringen (vergleichbar mit dem Path.GetRandomFileNameAnsatz).

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

Die letzten beiden Ansätze sehen besser aus, wenn Sie sie beispielsweise zu einer Erweiterungsmethode machen können System.Random.

nawfal
quelle
1
Die Verwendung chars.Selectist sehr hässlich, da die Ausgabegröße höchstens der Alphabetgröße entspricht.
CodesInChaos
@CodesInChaos Ich bin mir nicht sicher, ob ich dich verstehe. Du meinst im 'a'.To('z')Ansatz?
Nawfal
1
1) chars.Select().Take (n) `funktioniert nur wenn chars.Count >= n. Die Auswahl einer Sequenz, die Sie nicht verwenden, ist etwas uninteressant, insbesondere bei dieser impliziten Längenbeschränkung. Ich würde lieber Enumerable.Rangeoder verwenden Enumerable.Repeat. 2) Die Fehlermeldung "Das Endzeichen sollte kleiner sein als das Startzeichen" ist falsch herum / fehlt a not.
CodesInChaos
@CodesInChaos aber in meinem Fall chars.Countist Weg > n. Auch ich verstehe den unintuitiven Teil nicht. Das macht alle Verwendungen Takeunintuitiv, nicht wahr? Ich glaube es nicht. Vielen Dank für den Tippfehler.
Nawfal
4
Dies wird auf theDailyWTF.com als CodeSOD-Artikel vorgestellt.
22

Nur einige Leistungsvergleiche der verschiedenen Antworten in diesem Thread:

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

Ergebnisse

In LinqPad getestet. Für eine Zeichenfolgengröße von 10 wird Folgendes generiert:

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

Und die Leistungszahlen variieren in der Regel geringfügig, gelegentlich NonOptimizedist sie sogar schneller ForLoopund GenerateRandomStringwechseln manchmal , wer an der Spitze steht.

  • LinqIsTheNewBlack (10000x) = 96762 verstrichene Ticks (9,6762 ms)
  • ForLoop (10000x) = 28970 verstrichene Ticks (2,897 ms)
  • ForLoopNonOptimized (10000x) = 33336 verstrichene Ticks (3,3336 ms)
  • Wiederholen (10000x) = 78547 verstrichene Ticks (7,8547 ms)
  • GenerateRandomString (10000x) = 27416 verstrichene Ticks (2,7416 ms)
  • SecureFastRandom (10000x) = 13176 verstrichene Ticks (5 ms) am niedrigsten [Unterschiedliche Maschine]
  • SecureFastRandom-NoCache (10000x) = 39541 verstrichene Ticks (17 ms) am niedrigsten [Unterschiedlicher Computer]
drzaus
quelle
3
Es wäre interessant zu wissen, welche Dupes erstellt haben.
Rebecca
@Junto - um herauszufinden, was zu Duplikaten führt, so etwas wie var many = 10000; Assert.AreEqual(many, new bool[many].Select(o => EachRandomizingMethod(10)).Distinct().Count());, wo Sie durch EachRandomizingMethod... jede Methode ersetzen
drzaus
19

Eine Codezeile Membership.GeneratePassword()macht den Trick :)

Hier ist eine Demo dafür.

Pooran
quelle
Ich dachte daran, konnte aber die nicht alphanumerischen Zeichen nicht loswerden, da das zweite Argument die MINIMUM-Nicht-Alpha-Zeichen sind
ozzy432836
13

Der von Eric J. geschriebene Code ist ziemlich schlampig (es ist ziemlich klar, dass er von vor 6 Jahren stammt ... er würde diesen Code heute wahrscheinlich nicht schreiben), und es gibt sogar einige Probleme.

Im Gegensatz zu einigen der vorgestellten Alternativen ist diese kryptografisch fundiert.

Unwahr ... Es gibt eine Verzerrung im Passwort (wie in einem Kommentar geschrieben), bcdefghdie etwas wahrscheinlicher ist als die anderen (das aliegt nicht daran, GetNonZeroBytesdass keine Bytes mit dem Wert Null generiert werden, also die Verzerrung für diea wird dadurch ausgeglichen), so dass es nicht wirklich kryptografisch klingt.

Dies sollte alle Probleme beheben.

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

Wir verwenden auch benutzerdefinierte zufällige Zeichenfolgen, aber wir haben sie als Helfer für Zeichenfolgen implementiert, damit sie etwas Flexibilität bieten ...

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

Verwendungszweck

var random = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Random();

oder

var random = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".Random(16);
Mr. Pumpkin
quelle
7

Mein einfacher einzeiliger Code funktioniert für mich :)

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

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

Um dies für eine beliebige Zeichenfolge zu erweitern

    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);
    }
Raj Kumar
quelle
Ich mag die Guid-Methode auch - fühlt sich wirklich leicht an
ozzy432836
6

Eine andere Möglichkeit könnte darin bestehen, Linq zu verwenden und zufällige Zeichen zu einem Stringbuilder zusammenzufassen.

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());
AAD
quelle
6

Frage: Warum sollte ich meine Zeit damit verschwenden, Enumerable.Rangeanstatt einzutippen "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;
    }
}

Antwort: Magische Saiten sind SCHLECHT. Hat jemand bemerkt, dass es keine "I " in meiner Zeichenfolge war? Meine Mutter hat mir beigebracht, aus diesem Grund keine magischen Saiten zu benutzen ...

nb 1: Wie viele andere wie @dtb sagten, verwenden Sie es nicht, System.Randomwenn Sie kryptografische Sicherheit benötigen ...

nb 2: Diese Antwort ist nicht die effizienteste oder kürzeste, aber ich wollte, dass der Raum die Antwort von der Frage trennt. Der Zweck meiner Antwort ist eher, vor magischen Fäden zu warnen, als eine ausgefallene innovative Antwort zu liefern.

Wai Ha Lee
quelle
Warum kümmert es mich, dass es kein " I?"
Christine
1
Alphanumerisch (Groß- / Kleinschreibung ignorieren) ist [A-Z0-9]. Wenn Ihre zufällige Zeichenfolge versehentlich nur [A-HJ-Z0-9]das Ergebnis abdeckt, deckt sie nicht den gesamten zulässigen Bereich ab, was problematisch sein kann.
Wai Ha Lee
Wie wäre das problematisch? Also enthält es nicht I. Liegt es daran, dass es einen Charakter weniger gibt und das das Knacken erleichtert? Was sind die Statistiken zu knackbaren Passwörtern, die 35 Zeichen im Bereich von 36 enthalten? Ich denke, ich würde es lieber riskieren ... oder nur den Zeichenbereich prüfen ... als all diesen zusätzlichen Müll in meinen Code aufzunehmen. Aber das bin ich. Ich meine, um kein Arschloch zu sein, sage ich nur. Manchmal denke ich, dass Programmierer die Tendenz haben, den extrakomplexen Weg zu gehen, um extrakomplex zu sein.
Christine
1
Es vertieft sich auf den Anwendungsfall. Es ist sehr üblich, Zeichen wie Iund Ovon diesen Arten von zufälligen Zeichenfolgen auszuschließen , um zu vermeiden, dass Menschen sie mit 1und verwechseln 0. Wenn Sie sich nicht für eine für Menschen lesbare Zeichenfolge interessieren, ist das in Ordnung, aber wenn jemand etwas eingeben muss, ist es eigentlich klug, diese Zeichen zu entfernen.
Chris Pratt
5

Eine etwas sauberere Version der DTB-Lösung.

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

Ihre Stilvorlieben können variieren.

Rob Deary
quelle
Dies ist viel besser und effizienter als die akzeptierte Antwort.
Wedge
5
 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());
    }
Tejas
quelle
5

Nachdem ich die anderen Antworten überprüft und die Kommentare von CodeInChaos sowie die immer noch voreingenommene (wenn auch weniger) Antwort von CodeInChaos berücksichtigt hatte, dachte ich, dass eine endgültige Lösung zum Ausschneiden und Einfügen erforderlich ist. Während ich meine Antwort aktualisierte, beschloss ich, alles zu tun.

Eine aktuelle Version dieses Codes finden Sie im neuen Hg-Repository auf Bitbucket: https://bitbucket.org/merarischroeder/secureswiftrandom . Ich empfehle Ihnen, den Code zu kopieren und einzufügen von: https://bitbucket.org/merarischroeder/secureswiftrandom/src/6c14b874f34a3f6576b0213379ecdf0ffc7496ea/Code/Alivate.SolidSwiftRandom/SolidSwiftRandom.cs-vdef (stellen Sie sicher , klicken Klicken Sie auf die Schaltfläche "Roh", um das Kopieren zu vereinfachen und sicherzustellen, dass Sie über die neueste Version verfügen. Ich denke, dieser Link führt zu einer bestimmten Version des Codes, nicht zu der neuesten.

Aktualisierte Notizen:

  1. In Bezug auf einige andere Antworten - Wenn Sie die Länge der Ausgabe kennen, benötigen Sie keinen StringBuilder. Wenn Sie ToCharArray verwenden, wird das Array erstellt und gefüllt (Sie müssen nicht zuerst ein leeres Array erstellen).
  2. In Bezug auf einige andere Antworten - Sie sollten NextBytes verwenden, anstatt jeweils eine für die Leistung zu erhalten
  3. Technisch gesehen können Sie das Byte-Array für einen schnelleren Zugriff anheften. Es lohnt sich normalerweise, wenn Sie mehr als 6-8 Mal über ein Byte-Array iterieren. (Hier nicht gemacht)
  4. Verwendung von RNGCryptoServiceProvider für beste Zufälligkeit
  5. Gebrauch von Zwischenspeicherung eines 1-MB-Puffers mit zufälligen Daten - Benchmarking zeigt, dass die Zugriffsgeschwindigkeit zwischengespeicherter Einzelbytes ~ 1000x schneller ist - 9 ms über 1 MB gegenüber 989 ms für nicht zwischengespeicherte.
  6. Optimierte Unterdrückung der Vorspannungszone in meiner neuen Klasse.

Endlösung zur Frage:

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

Aber du brauchst meine neue (ungetestete) Klasse:

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

Für die Geschichte - meine ältere Lösung für diese Antwort, verwendetes Zufallsobjekt:

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

Performance:

  1. SecureFastRandom - Erster einzelner Lauf = ~ 9-33 ms . Unmerklich. Laufend : 5 ms (manchmal bis zu 13 ms) über 10.000 Iterationen, mit einer einzelnen durchschnittlichen Iteration = 1,5 Mikrosekunden. . Hinweis: Erfordert im Allgemeinen 2, gelegentlich jedoch bis zu 8 Cache-Aktualisierungen - hängt davon ab, wie viele einzelne Bytes die Bias-Zone überschreiten
  2. Zufällig - Erster einzelner Lauf = ~ 0-1 ms . Unmerklich. Laufend : 5 ms über 10.000 Iterationen. Mit einer einzelnen durchschnittlichen Iteration = 0,5 Mikrosekunden. . Etwa die gleiche Geschwindigkeit.

Schauen Sie sich auch an:

Diese Links sind ein weiterer Ansatz. Diese neue Codebasis könnte um Pufferung erweitert werden. Am wichtigsten war jedoch die Untersuchung verschiedener Ansätze zur Beseitigung von Verzerrungen und das Benchmarking der Geschwindigkeiten und Vor- und Nachteile.

Merari Schroeder
quelle
Ich fand einige leichte Leistungsverbesserungen an Ihrer Methode, die das Fasten
drzaus
5
1) Warum all diese magischen Konstanten? Sie spezifiziert die Ausgabelänge drei Mal. Definieren Sie es einfach als Konstante oder Parameter. Sie können charSet.Lengthanstelle von verwenden 62. 2) Eine statische RandomAufladung ohne Sperre bedeutet, dass dieser Code nicht threadsicher ist. 3) Das Reduzieren von 0-255 mod 62 führt eine nachweisbare Vorspannung ein. 4) Sie können nicht ToStringfür ein char-Array verwenden, das immer zurückgibt "System.Char[]". Sie müssen new String(rName)stattdessen verwenden.
CodesInChaos
Danke @CodesInChaos, ich habe damals noch nie an diese Dinge gedacht. Immer noch nur Random-Klasse, aber das sollte besser sein. Ich könnte mir keinen besseren Weg vorstellen, um Bias-Eingänge zu erkennen und zu korrigieren.
Todd
Es ist ein bisschen albern, mit einem schwachen RNG ( System.Random) zu beginnen und dann sorgfältig jegliche Verzerrung in Ihrem eigenen Code zu vermeiden. Der Ausdruck "Polieren eines Trottels" kommt mir in den Sinn.
CodesInChaos
@CodesInChaos Und jetzt hat der Lehrling seinen Meister übertroffen
Todd
4

Schrecklich, ich weiß, aber ich konnte mir einfach nicht helfen:


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

James
quelle
4

Ich habe nach einer genaueren Antwort gesucht, bei der ich das Format der zufälligen Zeichenfolge steuern möchte, und bin auf diesen Beitrag gestoßen. Zum Beispiel: Nummernschilder (von Autos) haben ein bestimmtes Format (pro Land) und ich wollte zufällige Nummernschilder erstellen.
Ich habe mich dazu entschlossen, meine eigene Erweiterungsmethode von Random zu schreiben. (Dies dient dazu, dasselbe zufällige Objekt wiederzuverwenden, da Sie in Multithreading-Szenarien Doppelte haben könnten.) Ich habe eine Liste erstellt ( https://gist.github.com/SamVanhoutte/808845ca78b9c041e928 ), werde aber auch die Erweiterungsklasse hier kopieren:

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)];
    }
}
Sam Vanhoutte
quelle
4

Jetzt im Einzeiler-Geschmack.

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());
}
Matas Vaitkevicius
quelle
2
Die Verwendung einer Eigenschaft für etwas, das sich bei jedem Zugriff ändert, ist eher zweifelhaft. Ich würde empfehlen, stattdessen eine Methode zu verwenden.
CodesInChaos
2
RNGCryptoServiceProvidersollte nach Gebrauch entsorgt werden.
Tsahi Asher
Ich habe das IDisposable-Problem behoben, aber dies ist immer noch sehr zweifelhaft, da für jeden Buchstaben ein neuer RNGCryptoServiceProvider erstellt wurde.
Piojo
@CodesInChaos fertig, jetzt eine Methode.
Matas Vaitkevicius
3

Versuchen Sie, zwei Teile zu kombinieren: eindeutig (Sequenz, Zähler oder Datum) und zufällig

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

Tests:

[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())
    }
RouR
quelle
1) Sie können Zeichenliterale anstelle der diesen Zeichen zugeordneten ASCII-Werte verwenden. 2) Sie haben einen Fehler in Ihrem Intervall-Matching-Code. Sie müssen <=und >=anstelle von <und verwenden >. 3) Ich würde die unnötigen Klammern um die &&Ausdrücke hinzufügen, um zu verdeutlichen, dass sie Vorrang haben, aber das ist natürlich nur eine stilistische Wahl.
CodesInChaos
+ 1 Gut zum Entfernen von Verzerrungen und zum Hinzufügen von Tests. Ich bin mir nicht sicher, warum Sie Ihrer zufälligen Zeichenfolge eine vom Zeitstempel abgeleitete Zeichenfolge voranstellen. Außerdem müssen Sie Ihren RNGCryptoServiceProvider
Montag,
2

Eine Lösung ohne Random:

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

var randomStr = new string(chars.SelectMany(str => str)
                                .OrderBy(c => Guid.NewGuid())
                                .Take(8).ToArray());
wb
quelle
2
NewGuid verwendet intern zufällig. Das wird also immer noch zufällig verwendet, es versteckt es nur.
Wedge
2

Hier ist eine Variante von Eric Js Lösung für WinRT (Windows Store App), dh kryptografisch einwandfrei:

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

Wenn Leistung wichtig ist (insbesondere wenn die Länge hoch ist):

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();
}
huyc
quelle
1
Dies ist nicht kryptografisch fundiert. Es gibt eine kleine Vorspannung aufgrund des Modulbetriebs, der nicht die gesamte Breite von ulong gleichmäßig auf 62 Zeichen verteilt.
Lie Ryan
1

Ich weiß, dass dies nicht der beste Weg ist. Aber du kannst es versuchen.

string str = Path.GetRandomFileName(); //This method returns a random file name of 11 characters
str = str.Replace(".","");
Console.WriteLine("Random string: " + str);
Sagar
quelle
2
Wie ist diese eine Zeile? Console.WriteLine ($ "Zufällige Zeichenfolge: {Path.GetRandomFileName (). Replace (". "," ")}"); ist eine Zeile.
PmanAce
1

Ich weiß nicht, wie kryptografisch das klingt, aber es ist bei weitem lesbarer und prägnanter als die komplizierteren Lösungen (imo), und es sollte "zufälliger" sein als System.Randombasierende Lösungen.

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

Ich kann mich nicht entscheiden, ob ich diese oder die nächste Version für "hübscher" halte, aber sie liefern genau die gleichen Ergebnisse:

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

Zugegeben, es ist nicht auf Geschwindigkeit optimiert. Wenn es also wichtig ist, jede Sekunde Millionen zufälliger Zeichenfolgen zu generieren, versuchen Sie es mit einer anderen!

HINWEIS: Diese Lösung erlaubt keine Wiederholungen von Symbolen im Alphabet. Das Alphabet MUSS gleich oder größer als die Ausgabezeichenfolge sein. Daher ist dieser Ansatz unter bestimmten Umständen weniger wünschenswert. Dies hängt alles von Ihrem Anwendungsfall ab.

Sara
quelle
0

Wenn Ihre Werte nicht völlig zufällig sind, sondern tatsächlich von etwas abhängen, können Sie einen md5- oder sha1-Hash dieses „Etwas“ berechnen und ihn dann auf die gewünschte Länge abschneiden.

Sie können auch eine Guid generieren und abschneiden.

Alexey B.
quelle
0
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;
    }
}
KregHEk
quelle
2
1) statische Methoden sollten threadsicher sein. 2) Was bringt es, den Index zu erhöhen, anstatt das Ergebnis von random.Nextdirekt zu verwenden? Kompliziert den Code und erreicht nichts Nützliches.
CodesInChaos
0

Hier ist ein Mechanismus zum Generieren einer zufälligen alphanumerischen Zeichenfolge (ich verwende diese, um Passwörter und Testdaten zu generieren), ohne das Alphabet und die Zahlen zu definieren.

CleanupBase64 entfernt die erforderlichen Teile in der Zeichenfolge und fügt weiterhin rekursiv zufällige alphanumerische Buchstaben hinzu.

        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);
        }
Dhanuka777
quelle
Sie haben erklärt GenerateRandomStringund rufen GetRandomStringvon innen an SanitiseBase64String. Auch haben Sie erklärt SanitiseBase64String und Call - CleanUpBase64Stringin GenerateRandomString.
Wai Ha Lee
0

Es gibt eines der großartigen Nuget-Pakete , die dies so einfach machen.

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

Eines der guten Beispiele ist hier .

nzrytmn
quelle
0

Nicht 100% sicher, da ich hier nicht JEDE Option getestet habe, aber von denen, die ich getestet habe, ist diese die schnellste. Es wurde mit einer Stoppuhr gemessen und es wurden 9 bis 10 Ticks angezeigt. Wenn also Geschwindigkeit wichtiger ist als Sicherheit, versuchen Sie Folgendes:

 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);
              }
     }
PetNoire
quelle
Warum antworten? Diese Frage wurde oft beantwortet und dennoch veröffentlichen Sie Ihre halbwegs funktionierende Antwort.
Laurent