.L152:
    mov    rcx, QWORD PTR [rax]
    add    rax, 8
    add    edx, DWORD PTR [rcx]
    cmp    rsi, rax
    jne    .L152

using System;
using System.Collections.Generic;

internal class GenericEqualityComparer<T> : EqualityComparer<T> where T : IEquatable<T>
{
    public override bool Equals(T x, T y)
    {
        if (x != null)
        {
            if (y != null) return x.Equals(y);
            return false;
        }
        if (y != null) return false;
        return true;
    }

    public override int GetHashCode(T obj) => obj?.GetHashCode() ?? 0;

    // ...
}

internal struct Foo : IEquatable<Foo>
{
    public bool Equals(Foo other)
    {
        Console.WriteLine("Equals(Foo other)");
        return true;
    }

    public override bool Equals(object obj)
    {
        Console.WriteLine("Equals(object obj)");
        return true;
    }

    public override int GetHashCode() => 0;
}

internal static class Program
{
    private static void Main()
    {
        var comparer = new GenericEqualityComparer<Foo>();
        var x = new Foo();
        var y = new Foo();
        var equal = comparer.Equals(x, y);
        Console.WriteLine(equal);
    }
}

EP>Ладно, вместо тысячи слов — встречайте её могущество копипаста без boost'а. Соотношения получились примерно те же самые

#include <iostream>
#include <chrono>
#include <stdlib.h>
using namespace std;

#define SIZE 4000*1000
int *array;
int *map1, *map2;
int test(int *map) 
{
        int sum = 0;
        for (int i=0; i<SIZE; i++)
                sum += array[map[i]];
        return sum;
}
int test0()
{
        int sum = 0;
        for (int i=0; i<SIZE; i++)
                sum += array[i];
        return sum;
}
int main()
{
        srand(time(0));
        array = new int[SIZE];
        map1 = new int[SIZE];
        for (int i=0;i<SIZE;i++) {
                map1[i] = i;
                array[i] = random();
        }
        map2 = new int[SIZE];
        for (int i=0;i<SIZE;i++)
                map2[i] = random()%SIZE;
        auto start0 = std::chrono::high_resolution_clock::now();
        int r = test0();
        auto finish0 = std::chrono::high_resolution_clock::now();
        cout << r << ":" <<std::chrono::duration_cast<std::chrono::nanoseconds>(finish0-start0).count() << "ns\n";

        auto start1 = std::chrono::high_resolution_clock::now();
        r = test(map1);
        auto finish1 = std::chrono::high_resolution_clock::now();
        cout << r << ":" << std::chrono::duration_cast<std::chrono::nanoseconds>(finish1-start1).count() << "ns\n";

        auto start2 = std::chrono::high_resolution_clock::now();
        r = test(map2);
        auto finish2 = std::chrono::high_resolution_clock::now();
        cout << r << ":" << std::chrono::duration_cast<std::chrono::nanoseconds>(finish2-start2).count() << "ns\n";
}

Понятно, что x => x.Y выглядит тривиально, это был лишь пример. В общем случае "оно" может быть не тривиальным, т.к. именно под нетривиальные объемы кода пишут те самые шаблоны "многоразового применения" — в этом их фишка.

where(x => x > q)

using System;
Q>using System.Collections.Generic;

Q>internal class GenericEqualityComparer<T> : EqualityComparer<T> where T : IEquatable<T>
Q>{
Q>    public override bool Equals(T x, T y)
Q>    {
Q>        if (x != null)
Q>        {
Q>            if (y != null) return x.Equals(y);
Q>            return false;
Q>        }
Q>        if (y != null) return false;
Q>        return true;
Q>    }

Q>    public override int GetHashCode(T obj) => obj?.GetHashCode() ?? 0;

Q>    // ...
Q>}

template<typename T>
bool is_equal(const T * x, const T * y) {
  if(x)
    return y ? *x == *y : false;  

  return !y;
}

template<typename T>
bool is_equal(const T & x, const T & y) {
  return x == y;  
}

internal sealed class ObjectEqualityComparer<T>: EqualityComparer<T>
    {
        [Pure]
        public override bool Equals(T x, T y) {
            if (x != null) {
                if (y != null) return x.Equals(y);
                return false;
            }
            if (y != null) return false;
            return true;
        }

Даже если у тебя будет констрейн where T : IBarable<T> — я уверен, ты сам сможешь доработать мой сниппет до такого сценария.

internal sealed class ObjectEqualityComparer<T>: EqualityComparer<T>

Навскидку, есть такой класс:

internal class GenericEqualityComparer<T>: EqualityComparer<T> where T: IEquatable<T>

internal sealed class ObjectEqualityComparer<T>: EqualityComparer<T>

Даже если у тебя будет констрейн where T : IBarable<T> — я уверен, ты сам сможешь доработать мой сниппет до такого сценария.

Собсно, вообще таких алгоритмов мало, которые можно выразить в дотнете для value и ref-типов в генериках и они будут корректно работать в обоих случаях.

V>internal sealed class ObjectEqualityComparer<T>: EqualityComparer<T>
V>    {
V>        [Pure]
V>        public override bool Equals(T x, T y) {
V>            if (x != null) {
V>                if (y != null) return x.Equals(y);
V>                return false;
V>            }
V>            if (y != null) return false;
V>            return true;
V>        }
V>

 public bool Equals(Person other)
   {
      if (other == null)
         return false;

      if (this.uniqueSsn == other.uniqueSsn)
         return true;
      else
         return false;
   }

   public override bool Equals(Object obj)
   {
      if (obj == null)
         return false;

      Person personObj = obj as Person;
      if (personObj == null)
         return false;
      else
         return Equals(personObj);
   }

using System;
using System.Collections.Generic;

internal struct /* or sealed class */ IntWrapper : IEquatable<IntWrapper>
{
    public IntWrapper(int i)
    {
        Value = i;
    }

    public int Value { get; }

    public bool Equals(IntWrapper other) => Value == other.Value;

    public override int GetHashCode() => Value.GetHashCode();

    public override bool Equals(object obj) { throw new NotSupportedException(); }

    public static bool operator ==(IntWrapper left, IntWrapper right) { throw new NotSupportedException(); }

    public static bool operator !=(IntWrapper left, IntWrapper right) { throw new NotSupportedException(); }
}

internal static partial class Program
{
    private static void Main()
    {
        var d = new Dictionary<IntWrapper, string>
        {
            { new IntWrapper(42), "Hello" },
            { new IntWrapper(1729), "World" },
        };

        var s = d[new IntWrapper(1729)];
        Console.WriteLine(s);
    }
}

public interface IEquatable<T>
{
    bool Equals(T other);
}

internal ...some-class...<T> ... where T : IEquatable<T>
{
    public override bool ...some-method...(T x, T y)
    {
        if (x != null)
        {
            if (y != null) return x.Equals(y);
            return false;
        }
        if (y != null) return false;
        return true;
    }

    ///...
}