我需要做的对象和NULL之间的comparaison。 当对象不为NULL我一些数据填充它。
下面是代码：
if (region != null)
{
....
}
这是工作，但循环和循环当某个区域的对象不为空（我可以看到在调试模式里面的数据）。 在一步一步的调试时，它不走了IF语句中......当我做一个快速监视与这些下面的表达式：我看到（区== NULL）返回false，AND（区！= NULL ）返回false太...... 为什么和怎么样？
更新
有人指出，对象是==和=超载！
public static bool operator ==(Region r1, Region r2)
{
if (object.ReferenceEquals(r1, null))
{
return false;
}
if (object.ReferenceEquals(r2, null))
{
return false;
}
return (r1.Cmr.CompareTo(r2.Cmr) == 0 && r1.Id == r2.Id);
}
public static bool operator !=(Region r1, Region r2)
{
if (object.ReferenceEquals(r1, null))
{
return false;
}
if (object.ReferenceEquals(r2, null))
{
return false;
}
return (r1.Cmr.CompareTo(r2.Cmr) != 0 || r1.Id != r2.Id);
}
是==和/或！=运算符重载为区域对象的类？
现在你已经张贴重载的代码：
重载或许应该像（由制造贴子采取以下代码乔恩斯基特和菲利普·里克 ）：
public static bool operator ==(Region r1, Region r2)
{
if (object.ReferenceEquals( r1, r2)) {
// handles if both are null as well as object identity
return true;
}
if ((object)r1 == null || (object)r2 == null)
{
return false;
}
return (r1.Cmr.CompareTo(r2.Cmr) == 0 && r1.Id == r2.Id);
}
public static bool operator !=(Region r1, Region r2)
{
return !(r1 == r2);
}
这些操作符重载被打破。
首先，它使生活更轻松很多，如果！=由只调用==和反相结果执行。
其次，在==无效性检查之前应该有：
if (object.ReferenceEquals(r1, r2))
{
return true;
}
无论是重载的是不正确的
public static bool operator ==(Region r1, Region r2)
{
if (object.ReferenceEquals(r1, null))
{
return false;
}
if (object.ReferenceEquals(r2, null))
{
return false;
}
return (r1.Cmr.CompareTo(r2.Cmr) == 0 && r1.Id == r2.Id);
}
如果R1和R2是空的，第一个测试（object.ReferenceEquals（R1，NULL））将返回false，即使R2也为空。
尝试
//ifs expanded a bit for readability
public static bool operator ==(Region r1, Region r2)
{
if( (object)r1 == null && (object)r2 == null)
{
return true;
}
if( (object)r1 == null || (object)r2 == null)
{
return false;
}
//btw - a quick shortcut here is also object.ReferenceEquals(r1, r2)
return (r1.Cmr.CompareTo(r2.Cmr) == 0 && r1.Id == r2.Id);
}
当你有多个线程使用相同的数据这有时会发生。 如果是这样的话，你可以用一个锁，以防止它们与海誓山盟搞乱。
对于类型“T”的相等比较，过载这些方法：
int GetHashCode() //Overrides Object.GetHashCode
bool Equals(object other) //Overrides Object.Equals; would correspond to IEquatable, if such an interface existed
bool Equals(T other) //Implements IEquatable<T>; do this for each T you want to compare to
static bool operator ==(T x, T y)
static bool operator !=(T x, T y)
您的类型特定的比较代码应在一个地方进行 ：类型安全IEquatable<T>接口方法Equals(T other) 。 如果你比较其他类型（T2），实现IEquatable<T2>为好，并把现场比较代码为类型的equals（T2等）。
所有重载方法和运营商应该转发相等比较任务到主类型安全的Equals（T除外）的实例方法，使得清洁依赖性的层次结构保持和更严格的保证在每个级别引入消除冗余和非本质的复杂性。
bool Equals(object other)
{
if (other is T) //replicate this for each IEquatable<T2>, IEquatable<T3>, etc. you may implement
return Equals( (T)other) ); //forward to IEquatable<T> implementation
return false; //other is null or cannot be compared to this instance; therefore it is not equal
}
bool Equals(T other)
{
if ((object)other == null) //cast to object for reference equality comparison, or use object.ReferenceEquals
return false;
//if ((object)other == this) //possible performance boost, ONLY if object instance is frequently compared to itself! otherwise it's just an extra useless check
//return true;
return field1.Equals( other.field1 ) &&
field2.Equals( other.field2 ); //compare type fields to determine equality
}
public static bool operator ==( T x, T y )
{
if ((object)x != null) //cast to object for reference equality comparison, or use object.ReferenceEquals
return x.Equals( y ); //forward to type-safe Equals on non-null instance x
if ((object)y != null)
return false; //x was null, y is not null
return true; //both null
}
public static bool operator !=( T x, T y )
{
if ((object)x != null)
return !x.Equals( y ); //forward to type-safe Equals on non-null instance x
if ((object)y != null)
return true; //x was null, y is not null
return false; //both null
}
讨论：
前述实施集中的类型特定的（即，场相等）相比，的端部IEquatable<T>实施的类型。 该==和!=运营商有一个平行的，但相反的实施。 我喜欢这个在具有一个参考其他的，使得存在一个额外的方法调用从属之一。 如果!=运算符只是要调用==操作符，而不是提出了一个同样的表演运营商，那么你可能也只是用!(obj1 == obj2)和避免额外的方法调用。 比较到自被从操作者的equals和左出IEquatable<T>实施方式中，因为它可以在某些情况下引入1.不必要的开销，和/或2.不一致的性能取决于一个实例是如何经常被比作本身VS其他实例。
我不喜欢，但应该提到另一种，是扭转这种设置，集中特定类型的平等代码在平等操盘手，并有方法取决于是，equals。 那么人们可以使用的快捷方式ReferenceEquals(obj1,obj2)检查引用相等，同时空平等菲利普在以前的文章中提到，但这种想法是一种误导。 好像你杀二鸟一石，但你的实际创造更多的工作 - 确定的对象既不是两个空也没有相同的实例后，然后你会，此外，还必须在检查是否每个实例一片空白。 在我的实现，你检查任何单个实例空一次。 由equals实例方法被调用的时候，它已经排除了被比较的第一个对象是空，那么所有剩下要做的就是检查对方是否为空。 所以，最多两个比较之后，我们直接跳到到现场检查，无论我们用哪一种方法（ Equals(object),Equals(T),==,!= ）。 此外，正如我所说，如果你真的是比较和反对本身大部分的时间，那么你可以只潜水前加入Equals方法是检查进入该领域的比较。 在最后的追加它的一点是，你仍可以保持流量/依赖性层次，而不在每个级别引入冗余/无用的检查。
因此，它是这里这些检查都是不对的：
public static bool operator !=(Region r1, Region r2)
{
if (object.ReferenceEquals(r1, null))
{
return false;
}
if (object.ReferenceEquals(r2, null))
{
return false;
}
...
还有，你需要点击旁边的，你看参数刷新图标另一种可能性。 VS尝试与性能跟不上，而不是评估每个语句/参数。 看看，以确保，你开始做更改这是不相关的地方了。
bool comp;
if (object.IsNullOrEmpty(r1))
{
comp = false;
}
if (object.IsNullOrEmpty(r2))
{
comp = false;
}
return comp;
