我收集了一些特例和脑筋急转弯，并且总是很愿意听到更多。该页面只涉及C#语言的各种细节，但我也认为核心的.NET知识也很有趣。例如，这里有一个不在页面上的例子，但我觉得它令人难以置信：
string x = new string(new char[0]);
string y = new string(new char[0]);
Console.WriteLine(object.ReferenceEquals(x, y));
我希望输出结果为False——毕竟，“new”（具有引用类型）总是创建一个新对象，不是吗？C#和CLI的规范都表明应该如此。但在这种特殊情况下不是这样。它打印True，并且在我测试过的每个框架版本上都是如此。（我承认我没有在Mono上尝试过...）
仅为明确起见，这只是我正在寻找的示例类型之一——我并不特别寻求对这种奇怪现象的讨论/解释。（它与普通字符串内插不同；��别是，当调用构造函数时，不会通常发生字符串内插。）我真正想问的是是否还有类似奇怪的行为。
是否还有其他隐藏的问题？
我想我之前向你展示过这个，但我喜欢这里的趣味 - 这需要一些调试才能追踪到！（原始代码显然更复杂和微妙...）
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());
}
所以，什么是Nullable<T> - 比如int?。除了GetType()方法不能被覆盖，其余所有方法都被覆盖；因此它被强制转换（装箱）为对象（因此为null），以调用object.GetType()...这将在空值上调用;-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。现在去洗洗眼睛吧！
银行家舍入。
这不是编译器错误或故障，但肯定是一个奇怪的角落案例......
.Net框架采用一种称为银行家舍入的舍入方案。
在银行家舍入中，0.5数字会被舍入到最接近的偶数，因此
Math.Round(-0.5) == 0
Math.Round(0.5) == 0
Math.Round(1.5) == 2
Math.Round(2.5) == 2
etc...
这可能会导致基于更为常见的Round-Half-Up舍入法进行的金融计算中出现一些意外的错误。
这也适用于Visual Basic。
Math.Round(x, MidpointRounding.AwayFromZero);来更改取整方式。 - ICRint(fVal + 0.5) 的原因。 - Ben Blank如果以 Rec(0) 形式调用此函数（非调试模式），它会执行什么操作？
static void Rec(int i)
{
Console.WriteLine(i);
if (i < int.MaxValue)
{
Rec(i + 1);
}
}
这是因为64位JIT编译器应用了尾调用优化，而32位JIT没有。
不幸的是，我手头没有64位计算机来验证这一点，但该方法符合所有尾调用优化的条件。如果有人有，请告诉我它是否正确。
++ 彻底把我搞糊涂了。你不能像正常人一样调用 Rec(i + 1) 吗？ - configurator这是我喜欢在聚会上问的问题（可能这就是为什么我不再被邀请了）：
你能让下面这段代码编译通过吗？
public void Foo()
{
this = new Teaser();
}
string cheat = @"
public void Foo()
{
this = new Teaser();
}
";
但真正的解决方案是这个：
public struct Teaser
{
public void Foo()
{
this = new Teaser();
}
}
事实上，很少有人知道值类型（结构体）可以重新分配它们的this变量。
//this = new Teaser(); :-) （注：这行代码在编程中被用作“恶作剧”，它试图将对象的指针 this 修改为一个新的 Teaser 对象的指针，从而影响程序的行为。） - AndrewJacksonZApublic Foo(int bar){this = new Foo(); specialVar = bar;}。这不是高效的，也不是真正有道理的（specialVar被分配了两次），但只是FYI。（这是书中给出的原因，我不知道为什么我们不应该只做public Foo(int bar) : this()） - kizzx2几年前，在开发忠诚度计划时，我们遇到了一个问题，涉及到将double转换为int的问题。
在下面的代码中：
double d = 13.6;
int i1 = Convert.ToInt32(d);
int i2 = (int)d;
i1 和 i2 是否相等？
结果显示 i1 与 i2 不相等。 由于 Convert 和 cast 操作符中存在不同的舍入策略，实际值如下:
i1 == 14
i2 == 13
调用Math.Ceiling()或Math.Floor()（或使用符合我们要求的MidpointRounding的Math.Round）总是更好的选择。
int i1 = Convert.ToInt32( Math.Ceiling(d) );
int i2 = (int) Math.Ceiling(d);
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");
}
}
}
0才能转换为枚举类型。请参考Eric Lippert的博客：http://blogs.msdn.com/b/ericlippert/archive/2006/03/28/563282.aspx。 - CodesInChaosobject 重载，为什么要强制转换成 int？JustTest((object)0) 应该会调用正确的方法。 - configuratorpublic class Turtle<T> where T : Turtle<T>
{
}
这段代码允许你声明它，但实际上没有什么用处，因为它总是要求你用另一个 Turtle 包装中心的任何类。
[玩笑] 我想这就是所谓的无底龟壳了... [/玩笑]
class RealTurtle : Turtle<RealTurtle> { } RealTurtle t = new RealTurtle(); - Marc Gravell这是我最近才发现的一个技巧...
interface IFoo
{
string Message {get;}
}
...
IFoo obj = new IFoo("abc");
Console.WriteLine(obj.Message);
IFoo的类”或“添加一个using别名来将IFoo指向一个类”这样的hack）。如果你能弄明白为什么，请看：谁说你不能实例化接口？
虽然我来晚了一点，但是我有 三 四 五个建议：
If you poll InvokeRequired on a control that hasn't been loaded/shown, it will say false - and blow up in your face if you try to change it from another thread (the solution is to reference this.Handle in the creator of the control).
Another one which tripped me up is that given an assembly with:
enum MyEnum
{
Red,
Blue,
}
if you calculate MyEnum.Red.ToString() in another assembly, and in between times someone has recompiled your enum to:
enum MyEnum
{
Black,
Red,
Blue,
}
at runtime, you will get "Black".
I had a shared assembly with some handy constants in. My predecessor had left a load of ugly-looking get-only properties, I thought I'd get rid of the clutter and just use public const. I was more than a little surprised when VS compiled them to their values, and not references.
If you implement a new method of an interface from another assembly, but you rebuild referencing the old version of that assembly, you get a TypeLoadException (no implementation of 'NewMethod'), even though you have implemented it (see here).
Dictionary<,>: "The order in which the items are returned is undefined". This is horrible, because it can bite you sometimes, but work others, and if you've just blindly assumed that Dictionary is going to play nice ("why shouldn't it? I thought, List does"), you really have to have your nose in it before you finally start to question your assumption.