A system I'm working on needs to generate and store unique codes that will be distributed to its users. Any user can then enter one of these codes to obtain a discount at the basket.

Because the codes are there for anybody's taking they need to be random enough that users who shouldn't have one shouldn't be able to go guessing them.

The codes will be handed out ad-hoc to users who will take the code and enter it at the basket. Nothing ties the code to any given user though.

The code I've come up with to generate the codes (read "pasted and modified off Google") is like this:

private readonly Random _rng = new Random();
private const string _chars = "ABCDEFGHJKLMNPQRSTWXY3456789";

public static string Generate(int size)
{
 char[] buffer = new char[size];

 for (int i = 0; i < size; i++)
 {
  buffer[i] = _chars[_rng.Next(_chars.Length)];
 }
 return new string(buffer);
}

It generates codes like this:

TWEXB8GE, WHJ55459, AEJA6XP5, D4J3RXJK, NRMALE8H, WMJGQAKY, YAQQKKX7

Notice that I've left out confusingly-similar characters combinations such as I and 1, Z and 2. Going further I could probably miss out S and 5 as well as 8 and B?

The issue I have is one of compromise. How do I balance uniqueness and "security" with ease of entry for the end user?

A string that's 8 characters long might not look too hard to guess, but is in fact fairly unique.

If the set of characters used has 28 members and the string is 8 characters long then the chance of guessing a code is one in 28^8 or 28 to the power or 8 or  28*28*28*28*28*28*28*28 or 377,801,998,336.

Assuming my maths is right?

Here's how some other combinations stack up:

Maybe a code 8 characters long is too much. Probably 6 would suffice. What would you opt for?