Creating a random name generator. How do I accomplish this?

I'm trying to grab a single item from each of the Lists here, and combine them to make a unique name. This is just for kicks. :)

Here are the lists:

List<string> FirstNames = new List<string>()
{
    "Sergio",
    "Daniel",
    "Carolina",
    "David",
    "Reina",
    "Saul",
    "Bernard",
    "Danny",
    "Dimas",
    "Yuri",
    "Ivan",
    "Laura"
};

List<string> LastNamesA = new List<string>()
{
    "Tapia",
    "Gutierrez",
    "Rueda",
    "Galviz",
    "Yuli",
    "Rivera",
    "Mamami",
    "Saucedo",
    "Dominguez",
    "Escobar",
    "Martin",
    "Crespo"
};

List<string> LastNamesB = new List<string>()
{
    "Johnson",
    "Williams",
    "Jones",
    "Brown",
    "David",
    "Miller",
    "Wilson",
    "Anderson",
    "Thomas",
    "Jackson",
    "White",
    "Robinson"
};

I know I get a single item via an index, and I also know that I can use the Random class to generate a random number from 0 to ListFoo.Count.

What I don't know is how to check if a random permutation has already been drawn from the collections.

I've thought about using the tuple class:

List<Tuple<int,int,int>> permutations = new List<Tuple<int,int,int>>();

But I'm having a brainfart here. ;) Any guidance? I'm not really looking for the entire code to this simple problem, just a suggestion or hint.

---

EDIT

Thanks to the suggestions given here, here what I've come up with. Any room for improvements?

static void Main(string[] args)
{
    List<string> FirstNames = new List<string>()
    {
        "Sergio",
        "Daniel",
        "Carolina",
        "David",
        "Reina",
        "Saul",
        "Bernard",
        "Danny",
        "Dimas",
        "Yuri",
        "Ivan",
        "Laura"
开发者_StackOverflow    };

    List<string> LastNamesA = new List<string>()
    {
        "Tapia",
        "Gutierrez",
        "Rueda",
        "Galviz",
        "Yuli",
        "Rivera",
        "Mamami",
        "Saucedo",
        "Dominguez",
        "Escobar",
        "Martin",
        "Crespo"
    };

    List<string> LastNamesB = new List<string>()
    {
        "Johnson",
        "Williams",
        "Jones",
        "Brown",
        "David",
        "Miller",
        "Wilson",
        "Anderson",
        "Thomas",
        "Jackson",
        "White",
        "Robinson"
    };

    var permutations = new List<Tuple<int, int, int>>();
    List<string> generatedNames = new List<string>();

    Random random = new Random();
    int a, b, c;

    //We want to generate 500 names.
    while (permutations.Count < 500)
    {
        a = random.Next(0, FirstNames.Count);
        b = random.Next(0, FirstNames.Count);
        c = random.Next(0, FirstNames.Count);

        Tuple<int, int, int> tuple = new Tuple<int, int, int>(a, b, c);

        if (!permutations.Contains(tuple))
        {
            permutations.Add(tuple);
        }
    }

    foreach (var tuple in permutations)
    {
        generatedNames.Add(string.Format("{0} {1} {2}", FirstNames[tuple.Item1], 
                                                        LastNamesA[tuple.Item2],
                                                        LastNamesB[tuple.Item3])
        );
    }

    foreach (var n in generatedNames)
    {
        Console.WriteLine(n);
    }

    Console.ReadKey();
}

---

You are on the right track! Every time you generate a name, add it to your tuple list

//Create the tuple
Tuple <int, int, int> tuple = new Tuple<int, int, int>(index1, index2, index3)

if(!permutations.Contains(tuple))
{ 
    permutations.Add(tuple);
    //Do something else
}

---

I would think the simplest solution is to just the stuff the assembled name into a HashSet<string> which will ensure the list of created names is unique.

---

An alternative to the HashSet answer is to build all of the possible combinations in advance, shuffle them, then store them in a Queue, where you can retrieve them one at a time. This will avoid having to check the existing ones every time you build a new one, and will still be random.

This only works if you don't have a large set to begin with, since the work involved in creating the complete list and shuffling it would be huge for a large set of data.

---

It's really easy to generate them all using LINQ:

var combs =
(from first in FirstNames
from second in LastNamesA
from third in LastNamesB
select new Tuple<string, string, string>(first, second, third)).ToList();

After this, if you need to take unique elements from the list randomly, just shuffle the list and then pick them one-by-one in order.

You can use the Knuth-Fisher-Yates algorithm (that's an in-place shuffle):

Random rand = new Random();

for (int i = combs.Count - 1; i > 0; i--)
{
    int n = rand.Next(i + 1);
    var mem = combs[i];
    combs[i] = combs[n];
    combs[n] = mem;
}

---

I would create a HashSet<int> and store the numeric representation of the picks (eg 135 for first, third and 5th or use 010305) and then check if they are in the set.

---

1. Create a new tuple with 3 random digits
2. Check if permutations contains your new tuple
3. If not => Add new tuple to the list. If yes, start with point 1 again.