如何处理 IEqualityComparer 中的空值？

Question

The following method is from XUnit Assert class:

public static void Equal<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqualityComparer<T> comparer);

And I am using it as:

IEnumerable<Decimal?> x = getXValues();
IEnumerable<Decimal?> y = getYValues();

Assert.Equal(x, y, new DecimalToleranceEqualityComparer(0.01m));

I am using an IEqualityComparer because is fine to consider 2.526 equal to 2.524.

I get an error because DecimalToleranceEqualityComparer is only for Decimal ...

x and y might have null values. DecimalToleranceEqualityComparer is:

  public class DecimalToleranceEqualityComparer : IEqualityComparer<Decimal> {

    private readonly Decimal _tolerance;

    public DecimalToleranceEqualityComparer(Decimal tolerance) {
      
      _tolerance = tolerance;

    } 

    public Boolean Equals(Decimal x, Decimal y) {

      return Math.Abs(x - y) <= _tolerance;

    } 

    public Int32 GetHashCode(Decimal obj) {

      return obj.GetHashCode();
    
    }

  } 

I suppose if 2 values are nulls they should be consider equal...

How to change the IEqualityComparer so that it handles nulls?

Answer 1

This code works for me. The real trick is in the imlementation of the Equals method. Also keep in mind the null check in the GetHashCode .

static void Main(string[] args)
{
    IEnumerable<Decimal?> x = new List<Decimal?> { 1.51m, 3, null };
    IEnumerable<Decimal?> y = new List<Decimal?> { 1.6m, 3, null };

    Assert.Equal(x, y, new DecimalToleranceEqualityComparer(0.1m));
}

public class DecimalToleranceEqualityComparer : IEqualityComparer<Decimal?>
{
    private readonly Decimal _tolerance;

    public DecimalToleranceEqualityComparer(Decimal tolerance)
    {

        _tolerance = tolerance;

    }

    public Boolean Equals(Decimal? x, Decimal? y)
    {
        if (!x.HasValue && !y.HasValue)
        {
            // Both null -> they are equal
            return true;
        }
        else if (!x.HasValue || !y.HasValue)
        {
            // One is null, other is not null -> not equal
            return false;
        }
        else
        {
            // both have values -> run the actual comparison
            return Math.Abs(x.Value - y.Value) <= _tolerance;
        }
    }

    public Int32 GetHashCode(Decimal? obj)
    {
        if (obj.HasValue)
        {
            return obj.GetHashCode();
        }
        else
        {
            // Here decide what you need
            return string.Empty.GetHashCode();
        }
    }
}

Answer 2

One option that comes to mind could be implementing new equality comparer for nullable decimal type IEqualityComparer<decimal?> which could use your existing DecimalToleranceEqualityComparer internally. Something like

public Boolean Equals(Decimal? x, Decimal? y) {
    return (x.HasValue && y.HasValue)?
     _decimalToleranceEqualityComparer.Equals(x.Value,y.Value)
    : x == y;
} 

Answer 3

You are supplying a list of Nullable<decimal> 's and your IEqualityComparer is expecting a list of Decimal 's.

With a rewrite like this you should be fine:

public class DecimalToleranceEqualityComparer : IEqualityComparer<decimal?>
{
    private readonly decimal _tolerance;

    public DecimalToleranceEqualityComparer(decimal tolerance)
    {
        _tolerance = tolerance;
    }

    public bool Equals(decimal? x, decimal? y)
    {
        if (!x.HasValue && !y.HasValue) return true;
        if (!x.HasValue || !y.HasValue) return false;

        return Math.Abs(x.Value - y.Value) <= _tolerance;
    }

    public int GetHashCode(decimal? obj)
    {
        return obj.GetHashCode();
    }
}