标签: iequalitycomparer

我遇到了Except()方法的麻烦.它不返回差异,而是返回原始集合.

我已经尝试在Account类中实现IEquatable和IEqualityComparer.我也尝试为Account创建一个单独的IEqualityComparer类.

当从main调用Except()方法时,它似乎不会调用我的自定义Equals()方法,但是当我尝试Count()时,它确实调用了自定义的GetHashCode()方法!

我确定我在某个地方犯了一个小错误,我希望一双新眼睛可以帮助我.

主要:

IEnumerable<Account> everyPartnerID = 
    from partner in dataContext.Partners
    select new Account { IDPartner = partner.ID, Name = partner.Name };


IEnumerable<Account> hasAccountPartnerID = 
    from partner in dataContext.Partners
    from account in dataContext.Accounts
    where
        !partner.ID.Equals(Guid.Empty) &&
        account.IDPartner.Equals(partner.ID) &&
        account.Username.Equals("Special")
    select new Account { IDPartner = partner.ID, Name = partner.Name };

IEnumerable<Account> noAccountPartnerID = 
    everyPartnerID.Except(
        hasAccountPartnerID, 
        new LambdaComparer<Account>((x, y) => x.IDPartner.Equals(y.IDPartner)));

帐户:

    public class Account : IEquatable<Account>
    {
        public Guid IDPartner{ get; set; }
        public string Name{ get; set; } …

我正在写一个解析器的一些单元测试,我被困在比较两个List<T>地方T是一类我自己的,包含其他List<S>.

我的UnitTest比较两个列表并失败.UnitTest中的代码如下所示:

CollectionAssert.AreEqual(list1, list2, "failed");

我写了一个测试场景,应该澄清我的问题:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ComparerTest
{
    class Program
    {
        static void Main(string[] args)
        {
            List<SimplifiedClass> persons = new List<SimplifiedClass>()
            {
                new SimplifiedClass()
                {
                 FooBar = "Foo1",
                  Persons = new List<Person>()
                  {
                    new Person(){ ValueA = "Hello", ValueB="Hello"},
                    new Person(){ ValueA = "Hello2", ValueB="Hello2"},
                  }
                }
            };
            List<SimplifiedClass> otherPersons = new List<SimplifiedClass>()
            {
                new SimplifiedClass()
                {
                 FooBar = "Foo1",
                  Persons = new …

我试图理解Enumerable.Except方法的两个重载之间的区别,即

• 除外(IEnumerable,IEnumerable)
• 除外(IEnumerable,IEnumerable,IEqualityComparer)

显然,第一个不同之处在于第一个重载使用默认的相等比较器,而另一个使用IEqualityComparer,但我可以通过实现IEquatable接口(如MSDN文档中提到的Except方法)实现与第一个方法相同的结果,然后为什么需要第二次过载？

类:

public class Point : IEqualityComparer<Point>
{               
    public char HorizontalPosition { get; set; }
    public int VerticalPosition { get; set; }

    public Point(char horizontalPosition, int verticalPosition)
    {
        HorizontalPosition = char.ToUpper(horizontalPosition);
        VerticalPosition = verticalPosition;           
    }   

    public bool Equals(Point x, Point y)
    {
        return (x.VerticalPosition == y.VerticalPosition && x.HorizontalPosition == y.HorizontalPosition);
    }

    public int GetHashCode(Point obj)
    {
        return (obj.HorizontalPosition.GetHashCode() + obj.VerticalPosition.GetHashCode());
    }
}

我试图在两个集合中找到共同点(交集),但结果是空集合 - 其中应包含两个元素.为什么？我已经实现了IEqualityComparer.我做错了什么吗？

示例集合:

  List<Point> first = new List<Point> { new Point('a', 1), new Point('b', 2) };
  List<Point> second …

我正在写一个有趣的节目,每次演出对我来说都是非常痛苦的.所以我想知道什么是更好的 - 制作一个额外的"if"语句来减少一些函数调用,或者避免那些"如果"adn获得更多的函数调用.该函数是虚方法,它覆盖IEqualityComparer的方法Equals,它所做的只是比较2个文件的大小和散列.if语句比较这两个文件的大小.我认为你明白了这个逻辑.你可以看到我正在用C#编写这个程序.所以也许任何人都可以回答我,因为这不是我第一次想知道该选择什么.谢谢

我目前有一个通用的方法,我想在它们之前对参数进行一些验证.具体来说,如果type参数的实例T是引用类型,我想检查它是否是null,ArgumentNullException如果它为null则抛出它.

有点像:

// This can be a method on a generic class, it does not matter.
public void DoSomething<T>(T instance)
{
    if (instance == null) throw new ArgumentNullException("instance");

请注意,我不希望使用来约束我喜欢的类型参数class的约束.

我以为我可以用马克Gravell的答案在"我怎么比一般类型为默认值？" ,并像这样使用EqualityComparer<T>类:

static void DoSomething<T>(T instance)
{
    if (EqualityComparer<T>.Default.Equals(instance, null))
        throw new ArgumentNullException("instance");

但它在调用时给出了一个非常模糊的错误Equals:

无法使用实例引用访问成员'object.Equals(object,object)'; 用类型名称来限定它

如何在不限制为值或引用类型的情况下检查T反对的实例？nullT

有没有办法为泛型类实现IEqualityComparer？

我试过了:

public class MyComparer : IEqualityComparer<MyGenericClass>

这是错误的,因为MyGenericClass将3个参数作为泛型,所以下一个

public class MyComparer : IEqualityComparer<MyGenericClass<A, B, C>>

这是错的,因为我不知道类型A,B,C.所以

public class MyComparer<MyGenericClass<A, B, C>> : IEqualityComparer<MyGenericClass<A, B, C>>

是错的.有没有办法实现这个？谢谢

我不太确定,为什么分组IEnumerable<string>不起作用.我当然提供自定义IEqualityComparer.

public class StringCollectionEqualityComparer : EqualityComparer<IEnumerable<string>>
{
    public override bool Equals(IEnumerable<string> x, IEnumerable<string> y)
    {
        if (Object.Equals(x, y) == true)
            return true;
        if (x == null) return y == null;
        if (y == null) return x == null;

        return x.SequenceEqual(y, StringComparer.OrdinalIgnoreCase);
    }

    public override int GetHashCode(IEnumerable<string> obj)
    {
        return obj.OrderBy(value => value, StringComparer.OrdinalIgnoreCase).Aggregate(0, (hashCode, value) => value == null ? hashCode :  hashCode ^ value.GetHashCode() + 33);
    }
}

class A
{
    public IEnumerable<string> StringCollection { get; set; …

我正在做一个应用程序来管理角色扮演会话的创建，但是我在做规则摘要的部分有问题，所以大师不必每秒钟都阅读核心书，我有这种方式的数据结构。

用户有一个战役列表，该战役有一个场景列表，场景有一个冒险列表。

用户 -> Lcampaings -> Lscenaries -> Ladventures

每个活动、场景或冒险都有资源，其中包含文档、图像、资源等列表以及摘要的散列集。

战役/场景/冒险 -> 资源 -> Ldocuments/LImages/.../HashSet 摘要

好的，所以为了修改我已经实现的等式和 gethashcode 的摘要

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Text;
using System.Windows;

namespace ElEscribaDelDJ.Classes
{
    public class Resumenes: INotifyPropertyChanged, IEqualityComparer<Resumenes>
    {

        private string _nombre;

        public string Nombre
        {
            get { return _nombre; }
            set { 
                _nombre = value;
                OnPropertyChanged("Nombre");
            }
        }

        private string _etiquetas;

        public string Etiquetas
        {
            get { return _etiquetas; }
            set { 
                _etiquetas = value;
                OnPropertyChanged("Etiquetas"); …

这就是我可以想出的检查空相等性的方法。它有效，但它看起来像 Shreak。以下内容适用于本示例：

x != null and y == null returns false;
x == null and y != null returns false;
x == null and y == null returns true;
x.ToString() == y.ToString() returns true;

我想我可以编写上面的代码，但我仍然觉得有一种更简洁的方法可以解决它。

public bool Equals(ConvertibleData x, ConvertibleData y)
{
    if (x == null)
    {
        if (y == null)
        {
            return true;
        }

        return false;
    }

    if (y == null)
    {
        return false;
    }

    return x.ToString() == y.ToString(); //Disregard the ToString, this coult be any comparer validation
}

在用于该文档中的"对实施者的说明"部分中GetHashCode的方法的的IEqualityComparer<T>接口,它规定:

需要实现以确保如果Equals方法对于两个对象x和y返回true,则x的GetHashCode方法返回的值必须等于为y返回的值.

众所周知,为什么你希望两个实例T在两个项相等的情况下返回相同的哈希码; 他们不同意味着他们不平等,而他们是相同意味着他们可能是平等的.

当两个实例不相等时,我将引用解释为未定义的返回值(即使它们的值可能表示如此).

以下面的例子为例.我有一个序列int?我想用于统计分类,其中每个非null int?表示一个类的属性(想想枚举值).在这些值为空的情况下,您不希望将值视为相等,因为它们会将训练集偏向缺失值.如果有的话,在这种情况下,当与其他空值比较时,您将需要空值以返回false.

问题是,在GetHashCode方法中,当给出null时,我可能想要返回0(或者其他一些数字,也许Int32.MinValue).现在,我知道当使用此IEqualityComparer<T>实现键入任何内容时,检查字典中是否存在键的性能对于这些情况不是最佳的.

也就是说GetHashCode,当调用Equals返回false 时,返回已知冲突的值为其他值时是否有效？我倾向于是,因为上面的引用在这个问题上是不确定的.