.net LinkedList.Contains。用于比较对象的方法是什么？

LinkedList.Contains方法。（.NET 2）

如何比较内部对象？（等于？比较？）

MSDN并没有告诉我们

情况：

interface IClass
{
    string GetName();
}

class Class1 : IClass, IEquatable<Class1>
{
    public string FirstName;
    public string LastName;

    string IClass.GetName() { return FirstName; }

    bool IEquatable<Class1>.Equals(Class1 other)
    {
        return FirstName.Equals(other.FirstName);
    }
}

class Class2 : IClass, IEquatable<Class2>
{
    public string FirstName;
    public string LastName;

    string IClass.GetName() { return LastName; }

    bool IEquatable<Class2>.Equals(Class2 other)
    {
        return LastName.Equals(other.LastName);
    }
}

public void TestMethod() 
{
    Class1 c1 = new Class1();
    c1.FirstName = "fn";
    c1.FirstName = "ln";

    Class2 c2 = new Class2();
    c2.FirstName = "fn";
    c2.FirstName = "ln";

    Class1 c3 = new Class1();
    c3.FirstName = "fn";
    c3.FirstName = "ln";

    LinkedList<IClass> myList = new LinkedList<IClass>();
    myList.AddFirst(c1);
    myList.AddFirst(c2);
    // false here
    MessageBox.Show("myList<IClass> contains c3? - " + (myList.Contains(c3)));

    LinkedList<Class1> myList1 = new LinkedList<Class1>();
    myList1.AddFirst(c1);
    myList1.AddFirst(c1);
    // true here
    MessageBox.Show("myList1<Class1> contains c3? - " + (myList1.Contains(c3)));
}

接口类
{
字符串GetName（）；
}
1类：IClass，IEquatable
{
公共字符串名；
公共字符串LastName；
字符串IClass.GetName（）{return FirstName；}
布尔等式等于（1类其他）
{
返回FirstName.Equals（其他.FirstName）；
}
}
第2类：IClass，IEquatable
{
公共字符串名；
公共字符串LastName；
字符串IClass.GetName（）{return LastName；}
布尔等式（第2类其他）
{
返回LastName.Equals（其他.LastName）；
}
}
公共void TestMethod（）
{
Class1 c1=新的Class1（）；
c1.FirstName=“fn”；
c1.FirstName=“ln”；
Class2 c2=新的Class2（）；
c2.FirstName=“fn”；
c2.FirstName=“ln”；
Class1 c3=新的Class1（）；
c3.FirstName=“fn”；
c3.FirstName=“ln”；
LinkedList myList=新建LinkedList（）；
myList.AddFirst（c1）；
myList.AddFirst（c2）；
//这里是假的
Show（“myList包含c3？”+（myList.contains（c3））；
LinkedList myList1=新建LinkedList（）；
myList1.AddFirst（c1）；
myList1.AddFirst（c1）；
//这里是真的
MessageBox.Show（“myList1包含c3？”+（myList1.contains（c3））；
}
由于链表不是字典，我希望它使用
EqualityComparer.Default.Equals（x，y）

这支持（按顺序）：


IEquatable
（用于所讨论的
T
）
object.Equals
（默认情况下使用引用相等，或支持重写的
Equals（object）
）

请注意，
EqualityComparer
还处理两个类和
Nullable
的常规
null
规则等

（更新：选中并更正；从
查找（T）
）

。。。
EqualityComparer comparer=EqualityComparer.Default；
...
如果（comparer.Equals（head.item，value））{…}
...


根据注释，当接口：IEquatable时，更新以证明此工作正常：

using System;
using System.Collections.Generic;


class Program
{
    static void Main()
    {
        LinkedList<IFoo> foos = new LinkedList<IFoo>();
        foos.AddLast(new Foo1("abc"));
        foos.AddLast(new Foo2("def"));
        Console.WriteLine("checking contains...");
        bool c = foos.Contains(new Foo1("ghi"));
        Console.WriteLine("...done");
    }
}
interface IFoo : IEquatable<IFoo>
{
    void Bar();
}
class Foo1 : IFoo
{
    public string Value { get; set; }
    public Foo1(string value) { Value = value; }
    public override bool Equals(object other)
    {
        Console.WriteLine(Value + " > override Equals");
        return base.Equals(other);
    }
    bool IEquatable<IFoo>.Equals(IFoo other)
    {
        Console.WriteLine(Value + " > explicit Equals");
        return base.Equals(other);
    }
    public void Bar() { }
    public override int GetHashCode() { return base.GetHashCode(); }
}
class Foo2 : IFoo
{
    public string Value { get; set; }
    public Foo2(string value) { Value = value; }
    public override bool Equals(object other)
    {
        Console.WriteLine(Value + " > override Equals");
        return base.Equals(other);
    }
    public bool Equals(IFoo other)
    {
        Console.WriteLine(Value + " > implicit Equals");
        return base.Equals(other);
    }
    public void Bar() { }
    public override int GetHashCode() { return base.GetHashCode(); }
}

使用系统；
使用System.Collections.Generic；
班级计划
{
静态void Main（）
{
LinkedList foos=新建LinkedList（）；
foos.AddLast（新Foo1（“abc”））；
foos.AddLast（新的Foo2（“def”））；
Console.WriteLine（“检查包含…”）；
bool c=foos.Contains（新的Foo1（“ghi”））；
控制台写入线（“…完成”）；
}
}
接口IFoo:IEquatable
{
空心钢筋（）；
}
类Foo1:IFoo
{
公共字符串值{get；set；}
公共Foo1（字符串值）{value=value；}
公共覆盖布尔等于（对象其他）
{
Console.WriteLine（值+“>override Equals”）；
返回基数。等于（其他）；
}
bool-IEquatable.Equals（如果oo-other）
{
Console.WriteLine（值+“>显式等于”）；
返回基数。等于（其他）；
}
公共无效条（）{}
公共重写int GetHashCode（）{return base.GetHashCode（）；}
}
第二类：IFoo
{
公共字符串值{get；set；}
公共Foo2（字符串值）{value=value；}
公共覆盖布尔等于（对象其他）
{
Console.WriteLine（值+“>override Equals”）；
返回基数。等于（其他）；
}
公共布尔等于（如果没有其他）
{
Console.WriteLine（值+“>隐式等于”）；
返回基数。等于（其他）；
}
公共无效条（）{}
公共重写int GetHashCode（）{return base.GetHashCode（）；}
}
要实现的方法是相等。我需要实现基本的Equals方法，而不一定是泛型方法

class Class1 : IClass, IEquatable<Class1>
{
    public string FirstName;
    public string LastName;

    string IClass.GetName() { return FirstName; }

    bool IEquatable<Class1>.Equals(Class1 other)
    {
        return FirstName.Equals(other.FirstName);
    }

    public override bool Equals(object obj)
    {
        if (obj is Class1)
        {
            return this.FirstName.Equals((obj as Class1).FirstName);
        }
        else
        {
            return base.Equals(obj);
        }
    }
}

类1:IClass，IEquatable
{
公共字符串名；
公共字符串LastName；
字符串IClass.GetName（）{return FirstName；}
布尔等式等于（1类其他）
{
返回FirstName.Equals（其他.FirstName）；
}
公共覆盖布尔等于（对象对象对象）
{
if（obj为1级）
{
返回这个.FirstName.Equals（（obj作为Class1.FirstName）；
}
其他的
{
返回基数等于（obj）；
}
}
}
是的，您能看到我在主题中发布的代码吗？问题是linkedList包含一个接口。但是对象也实现了IEquitable接口；他们需要为
LinkedList
实现
IEquatable
才能使用它。或者更具体地说，您需要
IClass:IEquatable
，因为对于所有
IClass
实现，它都需要为真。不，如果LinkedList T类型不是实现IEquitable的类型，则IEquitable的实现是不够的。在这种情况下，我需要重写object Equals方法。是的，它是-参见更新中的示例（以及我在上面的评论）@serhio:FYI在一般情况下，类似这样的内容会被编辑到您的问题中[尽管您可能在开始时没有要点]（用完整的示例回复评论）
class Class1 : IClass, IEquatable<Class1>
{
    public string FirstName;
    public string LastName;

    string IClass.GetName() { return FirstName; }

    bool IEquatable<Class1>.Equals(Class1 other)
    {
        return FirstName.Equals(other.FirstName);
    }

    public override bool Equals(object obj)
    {
        if (obj is Class1)
        {
            return this.FirstName.Equals((obj as Class1).FirstName);
        }
        else
        {
            return base.Equals(obj);
        }
    }
}