Generate random strings in vb.net

问题:

I need to generate random strings in vb.net, which must consist of (randomly chosen) letters A-Z (must be capitalized) and with random numbers interspersed. It needs to be able to generate them with a set length as well.

Thanks for the help, this is driving me crazy!

回答1:

If you can convert this to VB.NET (which is trivial) I'd say you're good to go (if you can't, use this or any other tool for what's worth):

/// <summary>
/// The Typing monkey generates random strings - can't be static 'cause it's a monkey.
/// </summary>
/// <remarks>
/// If you try hard enough it will eventually type some Shakespeare.
/// </remarks>
class TypingMonkey
{
   private const string legalCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

   static Random random = new Random();

   /// <summary>
   /// The Typing Monkey Generates a random string with the given length.
   /// </summary>
   /// <param name="size">Size of the string</param>
   /// <returns>Random string</returns>
   public string TypeAway(int size)
   {
       StringBuilder builder = new StringBuilder();
       char ch;

       for (int i = 0; i < size; i++)
       {
           ch = legalCharacters[random.Next(0, legalCharacters.Length)];
           builder.Append(ch);
       }

       return builder.ToString();
    }
}

Then all you've got to do is:

TypingMonkey myMonkey = new TypingMonkey();
string randomStr = myMonkey.TypeAway(size);

回答2:

Why don't you randomize a number 1 to 26 and get the relative letter.

Something like that:

Dim output As String = ""
Dim random As New Random()
For i As Integer = 0 To 9
   output += ChrW(64 + random.[Next](1, 26))
Next

Edit: ChrW added.

Edit2: To have numbers as well

    Dim output As String = ""
    Dim random As New Random()

    Dim val As Integer
    For i As Integer = 0 To 9
        val = random.[Next](1, 36)
        output += ChrW(IIf(val <= 26, 64 + val, (val - 27) + 48))
    Next

回答3:

C#

public string RandomString(int length)
{
    Random random = new Random();
    char[] charOutput = new char[length];
    for (int i = 0; i < length; i++)
    {
        int selector = random.Next(65, 101);
        if (selector > 90)
        {
            selector -= 43;
        }
        charOutput[i] = Convert.ToChar(selector);
    }
    return new string(charOutput);
}

VB.Net

Public Function RandomString(ByVal length As Integer) As String 
    Dim random As New Random() 
    Dim charOutput As Char() = New Char(length - 1) {} 
    For i As Integer = 0 To length - 1 
        Dim selector As Integer = random.[Next](65, 101) 
        If selector > 90 Then 
            selector -= 43 
        End If 
        charOutput(i) = Convert.ToChar(selector) 
    Next 
    Return New String(charOutput) 
End Function 

回答4:

How about:

Private Function GenerateString(len as integer) as String
        Dim stringToReturn as String=""
        While stringToReturn.Length<len
           stringToReturn&= Guid.NewGuid.ToString().replace("-","")
        End While
        Return left(Guid.NewGuid.ToString(),len)
End Sub

回答5:

Here's a utility class I've got to generate random passwords. It's similar to JohnIdol's Typing Monkey, but has a little more flexibility in case you want generated strings to contain uppercase, lowercase, numeric or special characters.

public static class RandomStringGenerator
{
    private static bool m_UseSpecialChars = false;

    #region Private Variables

    private const int m_MinimumLength = 8;
    private const string m_LowercaseChars = "abcdefghijklmnopqrstuvqxyz";
    private const string m_UppercaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private const string m_NumericChars = "123456890";
    private const string m_SpecialChars = "~?/@#!£$%^&*+-_.=|";

    #endregion

    #region Public Methods

    /// <summary>
    /// Generates string of the minimum length
    /// </summary>
    public static string Generate()
    {
        return Generate(m_MinimumLength);
    }

    /// <summary>
    /// Generates a string of the specified length
    /// </summary>
    /// <param name="length">The number of characters to generate</param>
    public static string Generate(int length)
    {
        return Generate(length, Environment.TickCount);
    }

    #endregion

    #region Private Methods

    /// <summary>
    /// Generates a string of the specified length using the specified seed
    /// </summary>
    private static string Generate(int length, int seed)
    {
        // Generated strings must contain at least 3 of the following character groups: uppercase letters, lowercase letters
        // numerals, and special characters (!, #, $, £, etc)

        // The generated string must be at least 4 characters  so that we can add a single character from each group.
        if (length < 4) throw new ArgumentException("String length must be at least 4 characters");

        StringBuilder SB = new StringBuilder();

        Random rand = new Random(seed);

        // Ensure that we add all of the required groups first
        SB.Append(GetRandomCharacter(m_LowercaseChars, rand));
        SB.Append(GetRandomCharacter(m_UppercaseChars, rand));
        SB.Append(GetRandomCharacter(m_NumericChars, rand));

        if (m_UseSpecialChars)
            SB.Append(GetRandomCharacter(m_SpecialChars, rand));

        // Now add random characters up to the end of the string
        while (SB.Length < length)
        {
            SB.Append(GetRandomCharacter(GetRandomString(rand), rand));
        }

        return SB.ToString();
    }

    private static string GetRandomString(Random rand)
    {
        int a = rand.Next(3);
        switch (a)
        {
            case 1:
                return m_UppercaseChars;
            case 2:
                return m_NumericChars;
            case 3:
                return (m_UseSpecialChars) ? m_SpecialChars : m_LowercaseChars;
            default:
                return m_LowercaseChars;
        }
    }

    private static char GetRandomCharacter(string s, Random rand)
    {
        int x = rand.Next(s.Length);

        string a = s.Substring(x, 1);
        char b = Convert.ToChar(a);

        return (b);
    }

    #endregion
}

To use it:

string a = RandomStringGenerator.Generate();   // Generate 8 character random string
string b = RandomStringGenerator.Generate(10); // Generate 10 character random string

This code is in C# but should be fairly easy to convert to VB.NET using a code converter.

回答6:

Just be simple. for vb just do:

Public Function RandomString(size As Integer, Optional validchars As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz") As String
    If size < 1 Or validchars.Length = 0 Then Return ""
    RandomString = ""
    Randomize()
    For i = 1 To size
        RandomString &= Mid(validchars, Int(Rnd() * validchars.Length) + 1, 1)
    Next
End Function

This function allows for a base subset of chars to use or user can choose anything. For example you could send ABCDEF0123456789 and get random Hex. or "01" for binary.

回答7:

Try this, it's the top answer already converted to VB!

Private Function randomStringGenerator(size As Integer)
    Dim random As Random = New Random()
    Dim builder As Text.StringBuilder = New Text.StringBuilder()
    Dim ch As Char
    Dim legalCharacters As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"

    For cntr As Integer = 0 To size
        ch = legalCharacters.Substring(random.Next(0, legalCharacters.Length), 1)
        builder.Append(ch)
    Next
    Return builder.ToString()
End Function