Generate unique string for Lucky number

Question

Possible Duplicate:
Unique random string generation

I have to generate a random unique string. The purpose of this is to generate a Lucky Number after every successful entry in a table.

I dont like to use GUID, since it is as dash(-) in between. Here is an example but it also seems too long.

I would like to generate a string which has around 10 chars.

Any good ideas would be much much appreciated. Cheers

Answer 1

You can create a string representation of a Guid without the dashes:

Guid.NewGuid().ToString("N");

Granted, it is 32 characters long, not 10. But it is a simple and fast solution.

Answer 2

You can try this one:

public struct ShortGuid
{
    private Guid _underlyingGuid;

    public ShortGuid(Guid underlyingGuid) : this()
    {
        _underlyingGuid = underlyingGuid;
    }

    public static ShortGuid Empty 
    {
        get { return ConvertGuidToShortGuid(Guid.Empty); }
    }

    public static ShortGuid NewShortGuid()
    {
        return ConvertGuidToShortGuid(Guid.NewGuid());
    }

    private static ShortGuid ConvertGuidToShortGuid(Guid guid)
    {
        return new ShortGuid(guid);
    }

    public override string ToString()
    {
        return Convert.ToBase64String(_underlyingGuid.ToByteArray()).EscapeNonCharAndNonDigitSymbols();
    }

    public bool Equals(ShortGuid other)
    {
        return other._underlyingGuid.Equals(_underlyingGuid);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (obj.GetType() != typeof (ShortGuid)) return false;
        return Equals((ShortGuid) obj);
    }

    public override int GetHashCode()
    {
        return _underlyingGuid.GetHashCode();
    }
}

where EscapeNonCharAndNonDigitSymbols is an extension method:

    public static string EscapeNonCharAndNonDigitSymbols(this string str)
    {
        if (str == null)
            throw new NullReferenceException();
        var chars = new List<char>(str.ToCharArray());

        for (int i = str.Length-1; i>=0; i--)
        {
            if (!Char.IsLetterOrDigit(chars[i]))
                chars.RemoveAt(i);
        }
        return new String(chars.ToArray());
    }

Answer 3

Just yesterday had to do the same task. Here you go:

public static class RandomStringService
{
    //Generate new random every time used. Must sit outside of the function, as static, otherwise there would be no randomness.
    private static readonly Random Rand = new Random((int)DateTime.Now.Ticks);


    /// <summary>
    /// Create random unique string- checking against a table
    /// </summary>
    /// <returns>Random string of defined length</returns>
    public static String GenerateUniqueRandomString(int length)
    {
        //check if the string is unique in Barcode table.
        String newCode;
        do
        {
            newCode = GenerateRandomString(length);

         // and check if there is no duplicates, regenerate the code again.
        } while (_tableRepository.AllRecords.Any(l => l.UniqueString == newCode));

//In my case _tableRepository is injected via DI container and represents a proxy for 
//EntityFramework context. This step is not really necessary, most of the times you can use 
//method below: GenerateRandomString

        return newCode;
    }




    /// <summary>
    /// Generates the random string of given length.
    /// String consists of uppercase letters only.
    /// </summary>
    /// <param name="size">The required length of the string.</param>
    /// <returns>String</returns>
    private static string GenerateRandomString(int size)
    {
        StringBuilder builder = new StringBuilder();
        char ch;
        for (int i = 0; i < size; i++)
        {
            ch = Convert.ToChar(CreateRandomIntForString());
            builder.Append(ch);
        }
        return builder.ToString();
    }



    /// <summary>
    /// Create a random number corresponding to ASCII uppercase or a digit
    /// </summary>
    /// <returns>Integer between 48-57 or between 65-90</returns>
    private static int CreateRandomIntForString()
    {
        //ASCII codes
        //48-57 = digits
        //65-90 = Uppercase letters
        //97-122 = lowercase letters

        int i;
        do
        {
            i = Convert.ToInt32(Rand.Next(48, 90));
        } while (i > 57 && i < 65);

        return i;
    }

Answer 4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;

namespace LinqRandomString
{
    class Program
    {
        static void Main(string[] args)
        {
            do
            {
                byte[] random = new byte[10000];

                using (var rng = RandomNumberGenerator.Create())
                    rng.GetBytes(random);


                var q = random
                            .Where(i => (i >= 65 && i <= 90) || (i >= 97 && i <= 122)) // ascii ranges - change to include symbols etc
                            .Take(10) // first 10
                            .Select(i => Convert.ToChar(i)); // convert to a character

                foreach (var c in q)
                    Console.Write(c);

            } while (Console.ReadLine() != "exit");
        }
    }
}