Calling a generic function with a contravariant IEqualityComparer

Question

I am trying to combine a couple of packages. UnitsNet containing all specific structs, and Microsoft Mvvm that hasa some nice Set<T> functions for properties with INotifyPropertyChanged. One of those Set<T> functions asks for an IEqualityComparer<T>.

I know that my QuantityEqualityComparer is the same for every struct from UnitsNet. And I saw that IEqualityComparer<in T> is contravariant. So I thought I understood that the following example should be possible. But the equality comparer is not accepted in this generic method.

It doesn't seem to be possible to cast _bar to IQuantity, and I also tried to call Set<IQuantity>(). But both statements get rejected by the compiler.

The solution I have implemented now is a caching mechanism that will create specific IEqualityComparers with reflection, but it seems like an overkill.

You can find the example here to play with it: https://dotnetfiddle.net/N7vfc9

using System;
using System.Collections.Generic;
                    
public class Program
{
    private static Length _bar;
    
    public static void Main()
    {
        // Error: cannot convert from QuantityEqualityComparer to IEqualityComparer<Length>
        Set(ref _bar, new Length(), new QuantityEqualityComparer());
    }
    
    // from Mvvm
    public static bool Set<T>(ref T field, T value, IEqualityComparer<T> comparer)
    {
        return true;
    }
}
            
public class QuantityEqualityComparer : IEqualityComparer<IQuantity>
{
    public bool Equals(IQuantity x, IQuantity y)
    {
        // custom implementation
    }
    
    public int GetHashCode(IQuantity obj)
    {
        // custom implementation
    }
}

// from UnitsNet
public interface IQuantity
{
}

public struct Length : IQuantity, IEquatable<Length>
{
    public bool Equals(Length other)
    {
        return true;
    }
}

Why not `QuantityEqualityComparer : IEqualityComparer where T:IQuantity`? — Jeremy Lakeman, May 11 '22 at 06:14
That is the solution that I have now, but that would make that I need to create a new `QuantityEqualityComparer` or any other subtype every time I need to call it. I would like to have one comparer for all. Also, in my own code I don't know the exact type of T. Only by reflection. — Marnix, May 11 '22 at 06:23
Seems like the problem is that `Length` is `struct`. If you change it to `class` it works, although I cannot explain why — Carlos, May 11 '22 at 06:30
Wow that's an interesting find. Did not expect that. Pity I can't change the UnitsNet code though. — Marnix, May 11 '22 at 06:32
`EqualityComparer.Default` should provide a cached instance, based on calling `IEquatable`. Which should just work. Or did you need your comparer to do something else? Note that a static `QuantityEqualityComparer.Instance` could serve as a cache per `T`. — Jeremy Lakeman, May 11 '22 at 06:32
Yes my comparer will have a custom implementation of `UnitsNet.Comparison.Equals(x.Value, yValueAsX, 1e-9, ComparisonType.Absolute)` — Marnix, May 11 '22 at 06:34

Jeremy Lakeman · Accepted Answer · 2022-05-11T06:56:18.350

Calling your QuantityEqualityComparer.Equals method would require the length struct to be boxed, which is why contravariance conversion fails.

Variance applies only to reference types; if you specify a value type for a variant type parameter, that type parameter is invariant for the resulting constructed type.

source

Though this might be similar to what you already have, this is what I would start with;

public static bool Set<T>(ref T field, T value)
    where T:IQuantity
=> Set<T>(ref field, value, QuantityEqualityComparer<T>.Instance);

public class QuantityEqualityComparer<T> : IEqualityComparer<T>
where T:IQuantity
{
    public static QuantityEqualityComparer<T> Instance = new();
    //...
}

Then use reflection or .Compile an expression tree to call this .Set<T> method.

I have something similar to this, but I was hoping for a solution that would use contravariance, so I could just have a single comparer for all, since the QuantityEqualityComparer can work with IQuantity and doesn't need to know anything about T. — Marnix, May 11 '22 at 06:54

Calling a generic function with a contravariant IEqualityComparer

1 Answers1