如何使用IEqualityComparer

我的数据库中有一些铃铛号相同。我希望所有这些都没有重复。我创建了一个compare类来完成这项工作，但是该函数的执行会导致该函数的延迟很大，没有区别，从0.6秒到3.2秒！

我做对了还是必须使用其他方法？

reg.AddRange(
    (from a in this.dataContext.reglements
     join b in this.dataContext.Clients on a.Id_client equals b.Id
     where a.date_v <= datefin && a.date_v >= datedeb
     where a.Id_client == b.Id
     orderby a.date_v descending 
     select new Class_reglement
     {
         nom  = b.Nom,
         code = b.code,
         Numf = a.Numf,
     })
    .AsEnumerable()
    .Distinct(new Compare())
    .ToList());

class Compare : IEqualityComparer<Class_reglement>
{
    public bool Equals(Class_reglement x, Class_reglement y)
    {
        if (x.Numf == y.Numf)
        {
            return true;
        }
        else { return false; }
    }
    public int GetHashCode(Class_reglement codeh)
    {
        return 0;
    }
}

您的GetHashCode实现始终返回相同的值。Distinct依靠良好的哈希函数可以有效地工作，因为它在内部构建哈希表。

在实现类的接口时，重要的一点是阅读文档，以了解您应该实现哪个合同。^1个

在你的代码，解决办法是转发GetHashCode到Class_reglement.Numf.GetHashCode并实施适当的存在。

除此之外，您的Equals方法中充满了不必要的代码。可以将其重写如下（相同的语义，代码的¼，更易读）：

public bool Equals(Class_reglement x, Class_reglement y)
{
    return x.Numf == y.Numf;
}

最后，该ToList呼叫是不必要且费时的：AddRange接受任何IEnumerable请求，因此List不需要转换为。AsEnumerable这也是多余的，因为处理结果AddRange仍然会导致这种情况。

^1在不知道代码实际作用的情况下编写代码称为“ 货物崇拜”编程。这是一种出奇的普遍做法。从根本上来说，它是行不通的。

试试下面的代码：

public class GenericCompare<T> : IEqualityComparer<T> where T : class
{
    private Func<T, object> _expr { get; set; }
    public GenericCompare(Func<T, object> expr)
    {
        this._expr = expr;
    }
    public bool Equals(T x, T y)
    {
        var first = _expr.Invoke(x);
        var sec = _expr.Invoke(y);
        if (first != null && first.Equals(sec))
            return true;
        else
            return false;
    }
    public int GetHashCode(T obj)
    {
        return obj.GetHashCode();
    }
}

它的使用示例是

collection = collection
    .Except(ExistedDataEles, new GenericCompare<DataEle>(x=>x.Id))
    .ToList(); 

只需代码，并实现GetHashCode和NULL验证：

public class Class_reglementComparer : IEqualityComparer<Class_reglement>
{
    public bool Equals(Class_reglement x, Class_reglement y)
    {
        if (x is null || y is null))
            return false;

        return x.Numf == y.Numf;
    }

    public int GetHashCode(Class_reglement product)
    {
        //Check whether the object is null 
        if (product is null) return 0;

        //Get hash code for the Numf field if it is not null. 
        int hashNumf = product.hashNumf == null ? 0 : product.hashNumf.GetHashCode();

        return hashNumf;
    }
}

示例：Numf区分的 Class_reglement列表

List<Class_reglement> items = items.Distinct(new Class_reglementComparer());

包含比较类（或更具体地说，AsEnumerable需要使用比较类才能使其工作）意味着排序逻辑已从基于数据库服务器变为在数据库客户端（您的应用程序）上。这意味着您的客户端现在需要检索然后处理大量的记录，这总是比在可以使用适当索引的数据库上执行查询效率低。

您应该尝试开发一个满足您要求的where子句，有关更多详细信息，请参见将IEqualityComparer与LINQ to Entities Except子句一起使用。

如果您想不装箱的通用解决方案：

public class KeyBasedEqualityComparer<T, TKey> : IEqualityComparer<T>
{
    private readonly Func<T, TKey> _keyGetter;

    public KeyBasedEqualityComparer(Func<T, TKey> keyGetter)
    {
        _keyGetter = keyGetter;
    }

    public bool Equals(T x, T y)
    {
        return EqualityComparer<TKey>.Default.Equals(_keyGetter(x), _keyGetter(y));
    }

    public int GetHashCode(T obj)
    {
        TKey key = _keyGetter(obj);

        return key == null ? 0 : key.GetHashCode();
    }
}

public static class KeyBasedEqualityComparer<T>
{
    public static KeyBasedEqualityComparer<T, TKey> Create<TKey>(Func<T, TKey> keyGetter)
    {
        return new KeyBasedEqualityComparer<T, TKey>(keyGetter);
    }
}

用法：

KeyBasedEqualityComparer<Class_reglement>.Create(x => x.Numf)

IEquatable<T> 使用现代框架可以更容易地做到这一点。

您将获得一个很好的简单bool Equals(T other)函数，并且无需进行任何转换或创建单独的类。

public class Person : IEquatable<Person>
{
    public Person(string name, string hometown)
    {
        this.Name = name;
        this.Hometown = hometown;
    }

    public string Name { get; set; }
    public string Hometown { get; set; }

    // can't get much simpler than this!
    public bool Equals(Person other)
    {
        return this.Name == other.Name && this.Hometown == other.Hometown;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();  // see other links for hashcode guidance 
    }
}

请注意，GetHashCode如果要在字典中使用或使用，则必须实现Distinct。

PS。我认为没有任何自定义的Equals方法可以直接在数据库端与实体框架一起使用（我想您知道这是因为您执行AsEnumerable），但这是在一般情况下执行简单Equals的简单得多的方法。

如果事情似乎不起作用（例如执行ToDictionary时出现重复的键错误），则在Equals内放置一个断点，以确保它被击中并确保已GetHashCode定义（使用override关键字）。