web-dev-qa-db-fra.com

Comment générer une chaîne aléatoire et spécifier la longueur souhaitée ou mieux créer une chaîne unique sur la spécification souhaitée

Il existe une bibliothèque pour générer des nombres aléatoires, alors pourquoi n’existe-t-il pas de bibliothèque pour la génération de chaînes aléatoires?

En d’autres termes, comment générer une chaîne aléatoire et spécifier la longueur souhaitée, ou mieux, générer une chaîne unique sur la spécification souhaitée, c’est-à-dire spécifier la longueur, une chaîne unique dans mon application me suffit.

Je sais que je peux créer un GUID (identificateur global unique), mais ceux-ci sont assez longs, ils doivent être plus longs.

int length = 8;
string s = RandomString.NextRandomString(length)
uniquestringCollection = new UniquestringsCollection(length)
string s2 = uniquestringCollection.GetNext();
c#stringrandom
34
HCP

Je ne me souviens pas d'où je l'ai eu, alors si vous savez qui est l'auteur de ceci à l'origine, aidez-moi à donner l'attribution.

private static void Main()
{
    const string AllowedChars =
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#@$^*()";
    Random rng = new Random();

    foreach (var randomString in RandomStrings(AllowedChars, 1, 16, 25, rng))
    {
        Console.WriteLine(randomString);
    }

    Console.ReadLine();
}

private static IEnumerable<string> RandomStrings(
    string allowedChars,
    int minLength,
    int maxLength,
    int count,
    Random rng)
{
    char[] chars = new char[maxLength];
    int setLength = allowedChars.Length;

    while (count-- > 0)
    {
        int length = rng.Next(minLength, maxLength + 1);

        for (int i = 0; i < length; ++i)
        {
            chars[i] = allowedChars[rng.Next(setLength)];
        }

        yield return new string(chars, 0, length);
    }
}
41
Jesse C. Slicer

Que diriez-vous-

    static Random rd = new Random();
    internal static string CreateString(int stringLength)
    {
        const string allowedChars = "ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz0123456789!@$?_-";
        char[] chars = new char[stringLength];

        for (int i = 0; i < stringLength; i++)
        {
            chars[i] = allowedChars[rd.Next(0, allowedChars.Length)];
        }

        return new string(chars);
    }
16
Jason Quinn

J'utilise couramment un code comme celui-ci pour générer une chaîne aléatoire:

internal static class Utilities {
  static Random randomGenerator = new Random();
  internal static string GenerateRandomString(int length) {
    byte[] randomBytes = new byte[randomGenerator.Next(length)];
    randomGenerator.NextBytes(randomBytes);
    return Convert.ToBase64String(randomBytes);
  }
}

Cela créera une chaîne codée en Base64 des octets aléatoires générés par l'objet aléatoire. Il n'est pas sécurisé pour les threads, donc plusieurs threads devront s'enrouler autour de lui. De plus, j'utilise un objet aléatoire statique afin que deux appels à la méthode en même temps ne reçoivent pas le même germe initial.

4
Joshua

Une bibliothèque pour générer des chaînes aléatoires ne serait pas très utile. Ce serait soit trop simple, de sorte que vous auriez souvent besoin de le remplacer de toute façon, soit trop complexe pour pouvoir couvrir toute situation possible, car vous le remplacez parce que c'est trop compliqué à utiliser.

Créer des chaînes aléatoires est assez facile en utilisant le générateur de nombres aléatoires, en fonction des détails exacts de vos besoins. Il est simplement plus efficace d'écrire le code spécifiquement pour chaque situation.

Si vous voulez une chaîne unique, il y a deux possibilités. Vous pouvez soit conserver chaque chaîne aléatoire créée afin de vérifier son unicité, soit vous pouvez la rendre très longue afin qu'il soit extrêmement improbable qu'il y ait des doublons. A GUID effectue ce dernier (ce qui explique pourquoi il est si long), donc il existe déjà une implémentation pour cela.

2
Guffa

Chaîne aléatoire utilisant des GUID concaténés

Cette approche utilise le nombre minimal de GUID concaténés pour renvoyer une chaîne aléatoire du nombre de caractères souhaité. 

    /// <summary>
    /// Uses concatenated then SubStringed GUIDs to get a random string of the
    /// desired length. Relies on the randomness of the GUID generation algorithm.
    /// </summary>
    /// <param name="stringLength">Length of string to return</param>
    /// <returns>Random string of <paramref name="stringLength"/> characters</returns>
    internal static string GetRandomString(int stringLength)
    {
        StringBuilder sb = new StringBuilder();
        int numGuidsToConcat = (((stringLength - 1) / 32) + 1);
        for(int i = 1; i <= numGuidsToConcat; i++)
        {
            sb.Append(Guid.NewGuid().ToString("N"));
        }

        return sb.ToString(0, stringLength);
    }

Exemple de sortie d'une longueur de 8:

39877037
2f1461d8
152ece65
79778fc6
76f426d8
73a27a0d
8efd1210
4bc5b0d2
7b1aa10e
3a7a5b3a
77676839
abffa3c9
37fdbeb1
45736489

Exemple de sortie avec une longueur de 40 (notez le "4" répété - dans un GUID v4, vous avez un chiffre hexadécimal qui sera toujours un 4 (suppression effective de 4 bits) - l'algorithme pourrait être amélioré en supprimant le "4" pour améliorer le caractère aléatoire, étant donné que la longueur renvoyée de la chaîne peut être inférieure à la longueur d'un GUID (32 caractères) ...):

e5af105b73924c3590e99d2820e3ae7a3086d0e3
e03542e1b0a44138a49965b1ee434e3efe8d063d
c182cecb5f5b4b85a255a397de1c8615a6d6eef5
676548dc532a4c96acbe01292f260a52abdc4703
43d6735ef36841cd9085e56f496ece7c87c8beb9
f537d7702b22418d8ee6476dcd5f4ff3b3547f11
93749400bd494bfab187ac0a662baaa2771ce39d
335ce3c0f742434a904bd4bcad53fc3c8783a9f9
f2dd06d176634c5b9d7083962e68d3277cb2a060
4c89143715d34742b5f1b7047e8107fd28781b39
2f060d86f7244ae8b3b419a6e659a84135ec2bf8
54d5477a78194600af55c376c2b0c8f55ded2ab6
746acb308acf46ca88303dfbf38c831da39dc66e
bdc98417074047a79636e567e4de60aa19e89710
a114d8883d58451da03dfff75796f73711821b02

Démo C # Fiddler: https://dotnetfiddle.net/Y1j6Dw

0
CJBS

Que diriez-vous quelque chose comme ça...

static string GetRandomString(int lenOfTheNewStr)
{
    string output = string.Empty;
    while (true)
    {
        output = output + Path.GetRandomFileName().Replace(".", string.Empty);    
        if (output.Length > lenOfTheNewStr)
        {
            output = output.Substring(0, lenOfTheNewStr);
            break;
        }
    }
    return output;
}

Sortie

static void Main(string[] args)
{            
    for (int x = 0; x < 10; x++)
    {
        string output = GetRandomString(20);
        Console.WriteLine(output);
    }
    Console.ReadKey();
}

 

r323afsluywgozfpvne4
qpfumdh3pmskleiavi3x
nq40h0uki2o0ptljxtpr
n4o0rzwcz5pdvfhmiwey
sihfvt1pvofgxfs3etxg
z3iagj5nqm4j1f5iwemg
m2kbffbyqrjs1ad15kcn
cckd1wvebdzcce0fpnru
n3tvq0qphfkunek0220d
ufh2noeccbwyfrtkwi02

Démo en ligne: https://dotnetfiddle.net/PVgf0k

Références
• https://www.dotnetperls.com/random-string

0
D T

Vous avez en quelque sorte répondu à votre propre question. il n'y a pas de fonction RandomString () car vous pouvez utiliser un générateur de nombres aléatoires pour générer facilement une chaîne.

1) Faites la plage de nombres entre les caractères ASCII que vous souhaitez inclure

2) Ajoutez chaque caractère à une chaîne jusqu'à ce que la longueur souhaitée soit atteinte.

3) Augmentez et répétez pour chaque chaîne nécessaire (ajoutez-les à un tableau, etc.)

Cela le ferait sûrement?

0
Siyfion