我认为这个问题的答案是因为。net使用字符串实习，这可能会导致相同的字符串指向相同的对象(因为字符串是可变的，这不是一个问题)

(我说的不是string类上重写的相等运算符)

我不久前问了一个问题:

条件运算符不能隐式强制转换?

考虑到:

Bool aBoolValue;

其中aBoolValue被赋值为True或False;

以下文件将无法编译:

Byte aByteValue = aBoolValue ? 1 : 0;

但这将:

Int anIntValue = aBoolValue ? 1 : 0;

提供的答案也很好。

下面是一个示例，说明如何创建导致错误消息“试图读写受保护内存”的结构。这通常表明其他记忆被破坏了。” 成功与失败的差别非常细微。

下面的单元测试演示了这个问题。

看看你能不能找出问题出在哪里。

    [Test]
    public void Test()
    {
        var bar = new MyClass
        {
            Foo = 500
        };
        bar.Foo += 500;

        Assert.That(bar.Foo.Value.Amount, Is.EqualTo(1000));
    }

    private class MyClass
    {
        public MyStruct? Foo { get; set; }
    }

    private struct MyStruct
    {
        public decimal Amount { get; private set; }

        public MyStruct(decimal amount) : this()
        {
            Amount = amount;
        }

        public static MyStruct operator +(MyStruct x, MyStruct y)
        {
            return new MyStruct(x.Amount + y.Amount);
        }

        public static MyStruct operator +(MyStruct x, decimal y)
        {
            return new MyStruct(x.Amount + y);
        }

        public static implicit operator MyStruct(int value)
        {
            return new MyStruct(value);
        }

        public static implicit operator MyStruct(decimal value)
        {
            return new MyStruct(value);
        }
    }

以下可能是我缺乏的常识，但是，嗯。前段时间，我们遇到了一个包含虚拟财产的bug案例。将上下文抽象一点，考虑以下代码，并将断点应用到指定区域:

class Program
{
    static void Main(string[] args)
    {
        Derived d = new Derived();
        d.Property = "AWESOME";
    }
}

class Base
{
    string _baseProp;
    public virtual string Property 
    { 
        get 
        {
            return "BASE_" + _baseProp;
        }
        set
        {
            _baseProp = value;
            //do work with the base property which might 
            //not be exposed to derived types
            //here
            Console.Out.WriteLine("_baseProp is BASE_" + value.ToString());
        }
    }
}

class Derived : Base
{
    string _prop;
    public override string Property 
    {
        get { return _prop; }
        set 
        { 
            _prop = value; 
            base.Property = value;
        } //<- put a breakpoint here then mouse over BaseProperty, 
          //   and then mouse over the base.Property call inside it.
    }

    public string BaseProperty { get { return base.Property; } private set { } }
}

而在Derived对象上下文中，您可以在添加基类时获得相同的行为。属性作为手表，或打字基地。财产成快表。

我花了些时间才意识到发生了什么。最后，我受到了Quickwatch的启发。当进入Quickwatch并探索派生对象d(或从对象的上下文，this)并选择字段基时，Quickwatch顶部的edit字段显示以下类型转换:

((TestProject1.Base)(d))

这意味着如果base被替换，调用会是

public string BaseProperty { get { return ((TestProject1.Base)(d)).Property; } private set { } }

对于watch、Quickwatch和调试鼠标移到工具提示，在考虑多态性时显示“AWESOME”而不是“BASE_AWESOME”是有意义的。我仍然不确定为什么它会转换成一个类型转换，一个假设是，调用可能无法从这些模块的上下文，只有callvirt。

无论如何，这显然不会改变派生功能方面的任何东西。BaseProperty仍然会返回“BASE_AWESOME”，因此这不是我们工作中的bug的根源，只是一个令人困惑的组件。然而，我发现有趣的是，它会误导开发人员，他们在调试过程中不会意识到这一事实，特别是如果Base没有在你的项目中公开，而是作为第三方DLL引用，导致开发人员只是说:

“喂，等等……什么?”omg那个DLL是 , . .做一些有趣的事情”

如果你有扩展方法:

public static bool? ToBoolean(this string s)
{
    bool result;

    if (bool.TryParse(s, out result))
        return result;
    else
        return null;
}

这段代码:

string nullStr = null;
var res = nullStr.ToBoolean();

这不会抛出异常，因为它是一个扩展方法(实际上是HelperClass.ToBoolean(null))，而不是一个实例方法。这可能会令人困惑。

在我们使用的API中，返回域对象的方法可能返回一个特殊的“空对象”。在此实现中，比较运算符和Equals()方法将被重写，如果与null进行比较则返回true。

所以这个API的用户可能会有这样的代码:

return test != null ? test : GetDefault();

或者更啰嗦一点，像这样:

if (test == null)
    return GetDefault();
return test;

其中GetDefault()是一个方法，返回一些我们想要使用的默认值，而不是null。当我使用ReSharper并按照它的建议重写这其中的任何一个时，我感到惊讶:

return test ?? GetDefault();

如果测试对象是从API返回的空对象，而不是一个正确的空对象，那么代码的行为现在已经改变，因为空合并操作符实际上检查null，而不是运行operator=或Equals()。