在我从这个问题中学到以下内容后,我想到了这一点:

where T : struct

我们C#开发人员都知道C#的基础知识.我的意思是声明,条件,循环,运算符等.

我们中的一些人甚至掌握了Generics,匿名类型,lambdas,LINQ等......

但是C#粉丝,瘾君子,专家几乎都不知道C#最隐藏的功能或技巧是什么？

以下是到目前为止显示的功能:

关键词

• yield由迈克尔·葡萄汁
• var由迈克尔·葡萄汁
• using()kokos的声明
• readonly由kokos
• as由迈克·斯通
• as/ is由埃德Swangren
• as/ is(改进)由Rocketpants
• default由deathofrats
• global::通过pzycoman
• using()由块AlexCuse
• volatile作者:JakubŠturc
• extern alias作者:JakubŠturc

属性

• DefaultValueAttribute由迈克尔·葡萄汁
• ObsoleteAttribute作者DannySmurf
• DebuggerDisplayAttribute由斯图
• DebuggerBrowsable并DebuggerStepThrough通过bdukes
• ThreadStaticAttribute通过 …

可能重复:
如何在没有无限递归的情况下检查'=='运算符重载中的空值？

对此可能有一个简单的答案......但它似乎在逃避我.这是一个简化的例子:

public class Person
{
   public string SocialSecurityNumber;
   public string FirstName;
   public string LastName;
}

让我们说,对于这个特定的应用程序,如果社会安全号码匹配,并且两个名称都匹配,那么我们指的是同一个"人"是有效的.

public override bool Equals(object Obj)
{
    Person other = (Person)Obj;
    return (this.SocialSecurityNumber == other.SocialSecurityNumber &&
        this.FirstName == other.FirstName &&
        this.LastName == other.LastName);
}

为了保持一致,我们还为团队中不使用该.Equals方法的开发人员覆盖==和!=运算符.

public static bool operator !=(Person person1, Person person2)
{
    return ! person1.Equals(person2);
}

public static bool operator ==(Person person1, Person person2)
{
    return person1.Equals(person2);
}

好又花花公子,对吧？

但是,当Person对象发生时会发生什么null？

你不能写:

if (person == null)
{
    //fail! …

问题如标题所述:将方法/属性标记为虚拟的性能影响是什么？

注意 - 我假设虚拟方法在常见情况下不会过载; 我通常会在这里使用基类.

我最近遇到过这种情况,到目前为止,我一直在愉快地重写等于运算符(==)和/或Equals方法,以查看两个引用类型是否实际包含相同的数据(即两个看起来相同的不同实例).

我一直在使用它,因为我已经进行了更多的自动化测试(比较参考/预期数据与返回的数据).

在查看MSDN中的一些编码标准指南时,我遇到了一篇建议反对它的文章.现在我理解为什么文章说这个(因为它们不是同一个实例)但它没有回答这个问题:

1. 比较两种参考类型的最佳方法是什么？
2. 我们应该实施IComparable吗？(我还看到提到这应该仅为值类型保留).
3. 有一些我不知道的界面吗？
4. 我们应该自己动手吗？!

非常感谢^ _ ^

更新

看起来我错误地阅读了一些文档(这是漫长的一天)并且压倒Equals可能是要走的路.

如果要实现引用类型,则应考虑在引用类型上覆盖Equals方法(如果类型看起来像基本类型,如Point,String,BigNumber等).大多数引用类型不应重载等于运算符,即使它们重写等于.但是,如果要实现旨在具有值语义的引用类型(例如复数类型),则应覆盖相等运算符.

使用该object.ReferenceEquals方法使用时会有额外的开销((object)obj1 == (object)obj2)吗？

在第一种情况下,将涉及静态方法调用,并且在两种情况下都涉及到对象的某种形式的转换.

即使编译器平衡了那些方法,那么不等式呢？

(object)obj != null

相比于...

!object.ReferenceEquals(obj,null)

我想在某些时候,会在!=运算符内或者应用于ReferenceEquals方法的结果时发生逻辑否定.你怎么看？

还有可读性问题需要考虑.在检查相等性时,ReferenceEquals似乎更清晰,但是对于不平等,可能会错过!前面的内容object.ReferenceEquals,而!=第一个变体中很难忽略.

有人可以解释一下这个重载是什么意思吗？

public static bool operator ==(Shop lhs, Shop rhs)
{
    if (Object.ReferenceEquals(lhs, null))
    {
        if (Object.ReferenceEquals(rhs, null))
        {
            return true;
        }
        return false;
    }

    return lhs.Equals(rhs);
}

我从未在重载中看到过Object.ReferenceEquals

当我尝试在C#中重载operator ==和!=并按推荐重写Equal时,我发现我无法区分普通对象和null.例如,我定义了一个类Complex.

public static bool operator ==(Complex lhs, Complex rhs)
{
    return lhs.Equals(rhs);
}

public static bool operator !=(Complex lhs, Complex rhs)
{
    return !lhs.Equals(rhs);
}

public override bool Equals(object obj)
{
    if (obj is Complex)
    {
        return (((Complex)obj).Real == this.Real &&
                   ((Complex)obj).Imaginary == this.Imaginary);
    }
    else
    {
        return false;
    }
}

但是当我想用的时候

if (temp == null)

当temp真的为null时,会发生一些异常.并且我不能使用==来确定lhs是否为null,这将导致无限循环.

在这种情况下我该怎么办

我能想到的一种方法是给我们一些像Class.Equal(对象,对象)(如果它存在的话)在我做检查时绕过==.

解决问题的正常方法是什么？

谢谢.

检查对象上的空引用的最有效方法是什么？我看过各种代码示例,它们有不同的检查方式,以便最有效或者被认为是最佳实践使用的方法如下:

Object.ReferenceEquals(item, null)

item == null

item != null

Object.Equals(item, null)

谢谢

请在下面的代码中查看我的评论.我应该如何检查参数null？它看起来像null被转换为Foo基本上使递归调用==操作符.为什么会这样？

public class Foo
{
    public static bool operator ==(Foo f1, Foo f2)
    {
        if (f1 == null) //This throw a StackOverflowException
            return f2 == null;
        if (f2 == null)
            return f1 == null;
        else
            return f1.Equals((object)f2);
    }

    public static bool operator !=(Foo f1, Foo f2)
    {
        return !(f1 == f2);
    }

    public override bool Equals(object obj)
    {
        Foo f = obj as Foo;
        if (f == (Foo)null)
            return false;

        return false; …

可能重复:
如何在没有无限递归的情况下检查'=='运算符重载中的空值？

当我为对象重载==运算符时,我通常写这样的东西:

    public static bool operator ==(MyObject uq1, MyObject uq2) {
        if (((object)uq1 == null) || ((object)uq2 == null)) return false;
        return uq1.Field1 == uq2.Field1 && uq1.Field2 == uq2.Field2;
    }

如果你没有向下转换为对象,那么函数可以自我复制,但我不得不怀疑是否有更好的方法？