C # 比较两个通用值

可能的复制品:
不能将运算符 = = 应用于 C # ? 中的泛型类型

我编写了这样的代码:

public bool IsDataChanged()
{
T value1 = GetValue2;
T value2 = GetValue1();


return (valueInDB != valueFromView);
}

现在这个函数没有用错误“ 运算符“ ! =”不能应用于类型为“ T”和“ T”的操作数”进行编译。要使这个函数工作，我需要做什么？

90469 次浏览
小开

That should work for you.

public bool test<T>(T test, T test2) where T : class
{
return (test != test2);
}

This is simply pasted from the examples that were commented on your question.

小开

You can overload the .Equals() method on your objects and change your evaluation to:

return (!valueInDB.Equals(valueFromView));

Assuming that valueInDB and valueFromView are objects. Your example variables aren't named the same as those used in the compare, so I had to assume.

EDIT: Got beat by 3 seconds! A note on overloading, if you need to compare values within a type, the basic .Equals() from the Object class won't be enough, as it will only do a memory compare for complex types. You'll need to overload and provide the implementation of how you want the object to be compared.

小开

Your type needs to implement the IComparable or IEquatable interface.

Probably you then need to rewrite a!=b as !(a==b), or call the CompareTo() or Equals() method explicitly.

小开
最佳答案

You cannot use operators on generic types (except for foo == null which is special cased) unless you add where T : class to indicate it is a reference type (then foo == bar is legal)

Use EqualityComparer<T>.Default to do it for you. This will not work on types which only supply an operator overload for == without also either:

  • implement IEquatable<T>
  • overrides object.Equals()

In general implementing the == operator and not also doing at least one of these would be a very bad idea anyway so this is not likely to be an issue.

public bool IsDataChanged<T>()
{
T value1 = GetValue2;
T value2 = GetValue1();


return !EqualityComparer<T>.Default.Equals(value1 , value2);
}

If you do not restrict to IEquatable<T> then the EqualityComparer default fallback may cause boxing when used with value types if they do not implement IEquatable<T> (if you control the types which are being used this may not matter). I am assuming you were using =! for performance though so restricting to the Generic type will avoid accidental boxing via the Object.Equals(object) route.


提交答案