Generate random strings in vb.net

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

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 

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

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.

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.

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