Using equality comparer in lambda expression

Question

I have a Venue class, and a Coordinate class like so:

class Venue
{
    string Name;
    Coordinate coordinate;
}

class Coordinate
{
    double latitute;
    double longitude;
}

Now, I want to be able to select a venue based on a coordinate as follows:

List<Venue> venues = GetAllVenues();

var myVenue = venues.FirstOrDefault(venue=>venue.coordinate == myCoordinate);

I have an IEqualityComparer implementation, but the lambda expression does not have an overload which takes the IEqualityComparer as a parameter.

How do I use my equality comparer in a lambda expression?

EDIT:

My equality comparer looks like this:

class CoordinatesEqualityComparer:IEqualityComparer<Coordinate>
    {
        public bool Equals(Coordinate x, Coordinate y)
        {
            return x.RowIndex == y.RowIndex && x.ColumnIndex == y.ColumnIndex;
        }

        public int GetHashCode(Coordinate obj)
        {
            return obj.GetHashCode();
        }
    }

When I do a Union() operation, like so, it does not work correctly, even though coordinates in both lists are same.

List<Coordinates> coordinates; 
CoordinatesEqualityComparer comparer; 
coordinates.Union(someOtherListOfCoordinates, comparer); 

However, when I do a union with itself, it works. What am I doing wrong? Does it have something to do with the GetHashCode() implementation?

Edit 2: Fixing the GetHashCode() method seems to do the trick.

public int GetHashCode(Coordinates obj)
        {
            // Warning:Hack. Use two prime numbers to generate a hash based on two properties.
            return obj.RowIndex.GetHashCode() * 7 + obj.ColumnIndex.GetHashCode() * 13 ;
        }

Answer 1

I would implement IEquatable<Coordinate>, override Equals(object), override GetHashCode(), and == != operators like this:

public class Coordinate : IEquatable<Coordinate>
{
    public double Latitide { get; set; }
    public double Longitude { get; set; }

    public bool Equals(Coordinate other)
    {
        if (other == null)
        {
            return false;
        }
        else
        {
            return this.Latitide == other.Latitide && this.Longitude == other.Longitude;
        }
    }

    public override bool Equals(object obj)
    {
        return this.Equals(obj as Coordinate);
    }

    public override int GetHashCode()
    {
        return this.Latitide.GetHashCode() ^ this.Longitude.GetHashCode();
    }

    public static bool operator ==(Coordinate value1, Coordinate value2)
    {
        if (!Object.ReferenceEquals(value1, null) && Object.ReferenceEquals(value2, null))
        {
            return false;
        }
        else if (Object.ReferenceEquals(value1, null) && !Object.ReferenceEquals(value2, null))
        {
            return false;
        }
        else if (Object.ReferenceEquals(value1, null) && Object.ReferenceEquals(value2, null))
        {
            return true;
        }
        else
        {
            return value1.Latitide == value2.Latitide && value1.Longitude == value2.Longitude;
        }
    }

    public static bool operator !=(Coordinate value1, Coordinate value2)
    {
        return !(value1 == value2);
    }
}

Answer 2

Have you tried:

var ec = new YourEqualityComparer();
var myVenue = venues.FirstOrDefault(venue => 
                                         ec.Equals(venue.coordinate, myCoordinate));

---

Of course, another approach would be to define the == operator for your Coordinate class and then you wouldn't need an IEqualityComparer:

class Coordinate
{
    double latitude;
    double longitude;

    public override bool Equals(object obj)
    {
        return Object.ReferenceEquals(this, obj)) ||
               this == (other as Coordinate);
    }

    public static bool operator ==(Coordinate l, Coordinate r)
    {
        return ((object)l == null && (object)r == null) || 
               ((object)l != null && (object)r != null) &&
               // equality check including epsilons, edge cases, etc.
    }

    public static bool operator !=(Coordinate l, Coordinate r)
    {
        return !(l == r);
    }
}