即使枚举函数重载，它们也应该使0为整数。

我知道c#核心团队将0映射到enum的基本原理，但是，它仍然没有像它应该的那样正交。来自Npgsql的例子。

测试的例子:

namespace Craft
{
    enum Symbol { Alpha = 1, Beta = 2, Gamma = 3, Delta = 4 };


   class Mate
    {
        static void Main(string[] args)
        {

            JustTest(Symbol.Alpha); // enum
            JustTest(0); // why enum
            JustTest((int)0); // why still enum

            int i = 0;

            JustTest(Convert.ToInt32(0)); // have to use Convert.ToInt32 to convince the compiler to make the call site use the object version

            JustTest(i); // it's ok from down here and below
            JustTest(1);
            JustTest("string");
            JustTest(Guid.NewGuid());
            JustTest(new DataTable());

            Console.ReadLine();
        }

        static void JustTest(Symbol a)
        {
            Console.WriteLine("Enum");
        }

        static void JustTest(object o)
        {
            Console.WriteLine("Object");
        }
    }
}

以下可能是我缺乏的常识，但是，嗯。前段时间，我们遇到了一个包含虚拟财产的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是 , . .做一些有趣的事情”

c#中的作用域有时真的很奇怪。让我给你们举个例子:

if (true)
{
   OleDbCommand command = SQLServer.CreateCommand();
}

OleDbCommand command = SQLServer.CreateCommand();

编译失败，因为命令被重新声明?在stackoverflow的这个帖子和我的博客中，有一些有趣的猜测，为什么它会这样工作。

我想我之前向您展示过这个，但我喜欢这里的乐趣——这需要一些调试才能跟踪!(原来的代码显然更加复杂和微妙……)

    static void Foo<T>() where T : new()
    {
        T t = new T();
        Console.WriteLine(t.ToString()); // works fine
        Console.WriteLine(t.GetHashCode()); // works fine
        Console.WriteLine(t.Equals(t)); // works fine

        // so it looks like an object and smells like an object...

        // but this throws a NullReferenceException...
        Console.WriteLine(t.GetType());
    }

那么T是什么?

答:任何可空<T> -如int?。所有的方法都被重写，除了GetType()不能;因此它被强制转换为object(因此为null)来调用object. gettype()…哪个调用null;-p

更新:情节变得越来越复杂……Ayende Rahien在他的博客上提出了类似的挑战，但使用了where T: class, new():

private static void Main() {
    CanThisHappen<MyFunnyType>();
}

public static void CanThisHappen<T>() where T : class, new() {
    var instance = new T(); // new() on a ref-type; should be non-null, then
    Debug.Assert(instance != null, "How did we break the CLR?");
}

但它是可以被打败的!使用与远程处理一样的间接方式;警告-以下是纯粹的邪恶:

class MyFunnyProxyAttribute : ProxyAttribute {
    public override MarshalByRefObject CreateInstance(Type serverType) {
        return null;
    }
}
[MyFunnyProxy]
class MyFunnyType : ContextBoundObject { }

在此之后，new()调用被重定向到代理(MyFunnyProxyAttribute)，该代理返回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()。

下面将打印False而不是抛出溢出异常:

Console.WriteLine("{0}", yep(int.MaxValue ));


private bool yep( int val )
{
    return ( 0 < val * 2);
}