null-coalescing operator with wildcard in a lambda expression

Question

I have a search form with multiple inputs - first name, last name, company...

I would like to return entities based on user inputs, or if nothing is input, in the last name field for instance, return all last names.

I believe I should be using null-coalescing for this, just like "ISNULL" in t-sql...

contacts = contacts.Where(s => s.firstname.ToUpper().Contains(fNameSearch.ToUpper() ?? *)

The issue is that I don't know how to use a wildcard in this type of experession.

For instance, this returns everything that contains "test" in the firstname property if fNameSearch is null or white-space...

 contacts = contacts.Where(s => s.firstname.ToUpper().Contains(fNameSearch.ToUpper() ?? "test")

but I want to be able to return everything, not just "test".

Answer 1

I believe I should be using null-coalescing for this:

fNameSearch.ToUpper() ?? *

Your belief is false. It only makes sense to use ?? when the left hand side can possibly be null. If fNameSearch is null then the call to ToUpper() throws; if it is not null then the call to ToUpper() produces a non-null string. So the ?? operator is not what you want to use.

The operator you're looking for is the lifted nullable member access operator:

fNameSearch.?ToUpper() ?? "test"

This means "if fNameSearch is null then produce null, give that to the ?? operator and get "test"; if it is not null then call ToUpper(), which will produce non-null string.

Unfortunately the .? operator does not exist in C#. It is a frequently requested feature, so perhaps a future version of the language will have it.

but I want to be able to return everything, not just "test".

Then you don't want either operator.

Take a step back. State what you want the predicate's behaviour to be.

• if fNameSearch is null then match everything
• otherwise, match firstName.ToUpper().Contains(fnameSearch.ToUpper)

OK, that's an easy predicate to write.

s => fNameSearch == null || s.firstname.ToUpper().Contains(fNameSearch.ToUpper())

So is this code correct?

No. ToUpper is not a good way to canonicalize a name. Remember, names are cultural artifacts and therefore must be searched using the correct rules for the culture associated with the name.

The correct way to do this is to obtain the CultureInfo object for the culture that the name is written in, and then call

culture.CompareInfo.IndexOf(firstname, fNameSearch, CompareOptions.IgnoreCase) 

and see if it comes back with a valid index or not.

Also, you probably should read this article before you write more code that tries to canonicalize names.

http://www.kalzumeus.com/2010/06/17/falsehoods-programmers-believe-about-names/

Answer 2

If you want to return everything, can't you place the condition before the query?

var contacts = /* construct your original query here */
if (fNameSearch != null)
    contacts = contacts.Where(s => s.firstname.ToUpper().Contains(fNameSearch.ToUpper());

Edit: Per Steve's comment below, case-sensitivity depends on the database's collation (and is case-insensitive by default), so you can just run:

var contacts = /* construct your original query here */
if (fNameSearch != null)
    contacts = contacts.Where(s => s.firstname.Contains(fNameSearch));

Edit₂: If you have multiple inputs to check for, you can use the same approach compositionally:

var contacts = /* construct your original query here */
if (string.IsNullOrEmpty(fNameSearch) == false))
    contacts = contacts.Where(s => s.firstname.Contains(fNameSearch));
if (string.IsNullOrEmpty(fSurnameSearch) == false))
    contacts = contacts.Where(s => s.surname.Contains(fSurnameSearch));
if (string.IsNullOrEmpty(fCompanySearch) == false))
    contacts = contacts.Where(s => s.company.Contains(fCompanySearch));