2

以下 [c#] 代码将无法编译，并出现错误“运算符 == 不能应用于 'T' 和 'T' 类型的操作数”。 

public class Widget<T> where T: IComparable
{
    public T value;
    public Widget(T input) { value = input; }
    public bool Equals<T>(Widget<T> w) where T : System.IComparable
    {
        return (w.value == value);
    }
}

有没有办法将 w 输入参数的类型 T 限制为与被比较对象相同的类型 T ，从而保证它们可以相互比较并消除编译器错误？在如下值前面使用 (dynamic) 可以编译，但似乎有更好的方法可以在编译时捕获问题：

public bool Equals<T>(Widget<T> w) where T : System.IComparable { return (w.value == (dynamic) value); }

4

4 回答 4

3

假设你真的对这里的价值平等感兴趣，你可以使用EqualityComparer.Default：

EqualityComparer<T> comparer = EqualityComparer<T>.Default;
return comparer.Equals(w.value, value);

请注意，目前您的Equals方法也是通用的，试图声明另一个类型参数 T。我认为您并不想这样做。

于 2012-05-10T19:29:01.387 回答
0 
public class Widget<T> where T: IComparable
{
    public T value;
    public Widget(T input) { value = input; }
    public bool Equals(Widget<T> other)
    {
        if(value == null)
        {
          return other == null || other.Value == null;
        }
        if(other == null) return false; //ensure next line doesn't get null pointer exception
        return value.CompareTo(other.Value) == 0;
    }
}

您可能需要根据您希望它在 、 和为 null 的各种排列下的行为方式来使用 nullvalue检查other逻辑other.value。

于 2012-05-10T19:29:16.067 回答
0

这是你想要的吗？

public class Widget<T> : IEquatable<Widget<T>>, IComparable<Widget<T>>
    where T : IEquatable<T>, IComparable<T>
{
    public T value;
    public Widget(T input) { value=input; }
    public override bool Equals(object obj)
    {
        if(obj is Widget<T>)
        {
            return Equals(obj as Widget<T>);
        }
        return false;
    }
    public override int GetHashCode()
    {
        return value.GetHashCode();
    }
    public bool Equals(Widget<T> other)
    {
        return value.Equals(other.value);
    }

    public int CompareTo(Widget<T> other)
    {
        return value.CompareTo(other.value);
    }
    public static bool operator==(Widget<T> a, Widget<T> b)
    {
        return a.Equals(b);
    }
    public static bool operator!=(Widget<T> a, Widget<T> b)
    {
        return !a.Equals(b);
    }
    public static bool operator<(Widget<T> a, Widget<T> b)
    {
        return a.CompareTo(b)==-1;
    }
    public static bool operator>(Widget<T> a, Widget<T> b)
    {
        return a.CompareTo(b)==1;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Widget<int> a=new Widget<int>(100);
        Widget<int> b=new Widget<int>(200);

        if(a==b||a>b)
        {
        }
    }
}
于 2012-05-10T19:34:39.073 回答
0 
public class Widget<T> where T: IEquatable<T>
{
    public T value;
    public Widget(T input) { value = input; }
    public bool Equals(Widget<T> w)
    {
        return (w.value.Equals(this.value));
    }
}

如果您需要相等比较，那么您应该使用IEquatable. IComparable更适合您还需要顺序比较（小于，大于）。

我认为您的主要错误是您在Equals<T>方法中引入了新的类型参数。不; 相反，让T参数Widget<T>中的 与实例化类的类型相同。这保证w.Value了 与 的类型相同this.value。

于 2012-05-10T19:52:05.323 回答