How to quickly match names (fname, lname) in different order with full name c#

Question

I have this linq query I am trying to optimize. I want to replace this query with a fast constant (preferably) retrieval of the value. I thought about a twin key dictionary but I have no idea which order the fname or lname will come first. I wanted to ask here if there is a fast way to do this.

I wanted to take a list of names, search through it for fname-lname the - is the delimeter and return all that match the full name that is searched. The list of people could be moderately large.

var nameList = from p in listOfPeople
               where ((p.lname+"-"+p.fname == fullName) 
               || (p.fname+"-"+p.lname == fullname)) 
               select p;

Edit: listOfPeople can be any datatype, not necessarily a list.

Answer 1

Here's how you can create your dictionary.

var nameLookup = new Dictionary<Tuple<string,string>, List<Person>>();
foreach(var person in listOfPeople)
{
    List<Person> people = null;
    var firstLast = Tuple.Create(person.fname, person.lname);
    if(nameLookup.TryGetValue(firstLast, out people))
    {
        people.Add(person);
    }
    else
    {
        nameLookup.Add(firstLast, new List<Person> { person });
    }

    // If the person's first and last name are the same we don't want to add them twice.
    if(person.fname == person.lname)
    {
        continue;
    }

    var lastFirst = Tuple.Create(person.lname, person.fname);
    if(nameLookup.TryGetValue(lastFirst, out people))
    {
        people.Add(person);
    }
    else
    {
        nameLookup.Add(lastFirst, new List<Person> { person });
    }
}

Then your lookup would be

// split by the delimiter to get these if needed
var fullName = Tuple.Create(firstName, lastName); 
List<Person> nameList = null;
if(!nameLookup.TryGetValue(fullName, out nameList))
{
    nameList = new List<Person>();
}

It's important to keep the first and last names separate or you have to pick a delimiter that will not show up the the first or last name. Hyphen "-" could be part of a first or last name. If the delimiter is guaranteed to not be part of the first or last name you can just substitute the use of the Tuple.Create(x,y) with x + delimiter + y and change the dictionary to Dictionary<string, List<Person>>.

Additionally the reason for having a List<Person> as the value of the dictionary is to handle cases like "Gary William" and "William Gary" being two different people.

Answer 2

I tested with Stopwatch and this appears to be a little more effective

 var nameList = from n in(
                        from p in listOfPeople
                          select new{FullName = p.fname +"-"+ p.lname}
                          )
                          where n.FullName==fullName
                          select n;

Answer 3

In your "P" definition, which I guess it's a "People" type, I would add a "FullName" property, which will be your comparator:

public string FullName {get {return fname + "-" + lname;}}

And modify your LINQ with: Where string.Equals(p.FullName, fullName) .

If you REALLY want to use with ANY datatype, which would include just string or even DataTable, i really don't see any better way than the way you did...