String Compare where null and empty are equal

Question

Using C# and .NET 3.5, what's the best way to handle this situation. I have hundreds of fields to compare from various sources (mostly strings). Sometimes the source returns the string field as null and sometimes as empty. And of course, sometimes there is text in the fields. My current comparison of strA != strB isn't cutting it because strA is null and strB is "", for example. I know I could do the string.IsNullOrEmpty which results in a double comparison and some ugliness. Is there a better way to handle this? I thought extension methods, but you can't extend operators.

I guess I'm looking for a sexy way to do this.

Answer 1

Doesn't eliminate the extra underlying comparisons, but for the sexiness factor, you could use something like this:

(strA ?? "") == (strB ?? "")

or the slightly less sexy, but preferable form:

(strA ?? string.Empty) == (strB ?? string.Empty)

Answer 2

Since you've got hundreds of comparisons to do, it sounds like you want a single function to call so that you can reduce the clutter and repetition in your code. I don't think there is a built-in function to do a null/empty string/comparison check all in one, but you could just make one yourself:

static class Comparison
{
    public static bool AreEqual(string a, string b)
    {
        if (string.IsNullOrEmpty(a))
        {
            return string.IsNullOrEmpty(b);
        }
        else
        {
            return string.Equals(a, b);
        }
    }
}

Then you could just use a single call to your function for each comparison:

        if(Comparison.AreEqual(strA[0], strB[0])) { // ... }
        if(Comparison.AreEqual(strA[1], strB[1])) { // ... }
        if(Comparison.AreEqual(strA[2], strB[2])) { // ... }
        if(Comparison.AreEqual(strA[3], strB[3])) { // ... }

This approach is also easier to expand if you later find that you need to worry about additional situations, such as ignoring whitespace at the beginning or ending of strings; you can then just add more logic to your function to do some trimming or whatever and you won't have to make any modifications to the hundreds of lines of code calling your function.

Answer 3

Not as sexy as ??, but you could avoid the double comparison part of the time if you short-circuit it:

string.IsNullOrEmpty( strA ) ? string.IsNullOrEmpty( strB ) : (strA == strB )

Answer 4

What about

strA ?? "" == strB ?? ""

Answer 5

Addition After a few years, and writing several equality comparers, my opinion has changed, such that I think it is better for the equality comparer to have a static member that holds the created comparer, instead of every user creating a new instance.

---

(original answer, with the adjustment mentioned above)

The solutions others gave, including the one that proposes to define a Comparison class for the strings, forgot to write a new GetHashCode for your strings.

This means that your string can't be used in classes that depend upon GetHashCode like Dictionary<T> or HashSet<T>.

See Why is it important to override GetHashCode when Equals method is overridden?

Whenever you decide to change the concept of equality for any class, you should write an EqualityComparer for that class. This makes sure that if according to your changed definition of equality to objects are considered equal, their GetHashCode would return equal values.

public class NullStringComparer : EqualityComparer<string>
{
    public static IEqualityComparer<string> NullEqualsEmptyComparer {get} = new NullStringComparer();

    public override bool Equals(string x, string y)
    {
        // equal if string.Equals(x, y)
        // or both StringIsNullOrEmpty
        return String.Equals(x, y)
            || (String.IsNullOrEmpty(x) && String.IsNullOrEmpty(y));
    }

    public override int GetHashCode(string obj)
    {
        if (String.IsNullOrEmpty(obj))
           return 0;
        else
            return obj.GetHashCode();
    }
}

Usage:

public static void Main()
{
    string x = null;
    string y = String.Empty;

    Console.WriteLine("Standard string comparison: {0}", 
        StringComparer.Ordinal.Equals(x, y));

    Console.WriteLine($"My string comparison {0}",
        NullStringComparer.NullEqualsEmpty.Equals(x, y));

    // because according to the NullStringComparer x equals y
    // GetHashCode should return the same value
    int hashX = NullStringComparer.NullEqualsEmpty.GetHashCode(x);
    int hashY = NullStringComparer.NullEqualsEmpty.GetHashCode(y);
    Console.WriteLine($"hash X = {hashX}, hash Y = {hashY}");
} 

Answer 6

This also works, ignoring cases

(strA ?? "").Equals(strB ?? "", StringComparison.OrdinalIgnoreCase)

Answer 7

What's wrong with string.IsNullOrEmpty()? I'm sure that since it is part of the .NET framework it's optimized and probably far more efficient than something you or I could write. It may not be sexy but it works. Write code that is easily readable and let the compiler sort out the details.

Answer 8

If you your 2 sets of fields are in some sort of collection, you may be able to use LINQ to your advantage. If they are in some sort of collection that allows you to access them by key and they both have the same keys, you can use this (ready to be pasted into LINQPad):

Dictionary<string,string> fields1 = new Dictionary<string,string>();
Dictionary<string,string> fields2 = new Dictionary<string,string>();

fields1.Add("field1", "this");
fields2.Add("field1", "this");
fields1.Add("field2", "is");
fields2.Add("field2", "");
fields1.Add("field3", "a");
fields2.Add("field3", null);
fields1.Add("field4", "test");
fields2.Add("field4", "test");

var test = 
from f1 in fields1
    join f2 in fields2
    on f1.Key equals f2.Key
select (f1.Value ?? "") == (f2.Value ?? "");

test.Dump();

If you have the sets of fields in 2 indexed collections in the same order, you could use something like this:

string[] strings1 = { "this", "is", "a", "test" };
string[] strings2 = { "this", "", null, "test" };

var test = 
from s1 in strings1.Select((value,index) => new {value, index})
    join s2 in strings2.Select((value,index) => new {value, index})
    on s1.index equals s2.index
select (s1.value ?? "") == (s2.value ?? "");

test.Dump();