我最近正在处理一个DateTime对象，并编写了如下内容：

DateTime dt = DateTime.Now;
dt.AddDays(1);
return dt; // still today's date! WTF?

的intellisense文档AddDays()说，它在日期上添加了一天，但没有添加-实际上返回了一个日期，其中添加了一天，因此您必须这样写：

DateTime dt = DateTime.Now;
dt = dt.AddDays(1);
return dt; // tomorrow's date

以前，这已经咬了我很多次，所以我认为对最糟糕的C＃陷阱进行分类将很有用。

private int myVar;
public int MyVar
{
    get { return MyVar; }
}

布拉莫 您的应用崩溃，没有堆栈跟踪。一直发生。

（注意使用大写MyVar字母而不是小写字母myVar）。

Type.GetType

我看到很多人咬过的是Type.GetType(string)。他们想知道为什么它适用于他们自己的程序集中的类型，而某些类型像System.String，而不是System.Windows.Forms.Form。答案是，它仅在当前程序集中和中查找mscorlib。

匿名方法

C＃2.0引入了匿名方法，导致了如下讨厌的情况：

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        for (int i=0; i < 10; i++)
        {
            ThreadStart ts = delegate { Console.WriteLine(i); };
            new Thread(ts).Start();
        }
    }
}

那会打印出什么？好吧，这完全取决于调度。它会打印10个数字，但可能不会打印0、1、2、3、4、5、6、7、8、9，这可能是您期望的。问题在于i捕获的变量是变量，而不是在创建委托时的值。使用正确范围的额外局部变量可以轻松解决此问题：

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        for (int i=0; i < 10; i++)
        {
            int copy = i;
            ThreadStart ts = delegate { Console.WriteLine(copy); };
            new Thread(ts).Start();
        }
    }
}

推迟执行迭代器块

这个“穷人的单元测试”没有通过-为什么不呢？

using System;
using System.Collections.Generic;
using System.Diagnostics;

class Test
{
    static IEnumerable<char> CapitalLetters(string input)
    {
        if (input == null)
        {
            throw new ArgumentNullException(input);
        }
        foreach (char c in input)
        {
            yield return char.ToUpper(c);
        }
    }

    static void Main()
    {
        // Test that null input is handled correctly
        try
        {
            CapitalLetters(null);
            Console.WriteLine("An exception should have been thrown!");
        }
        catch (ArgumentNullException)
        {
            // Expected
        }
    }
}

答案是，CapitalLetters直到MoveNext()首次调用迭代器的方法时，代码源中的代码才会执行。

我的脑筋急转弯页面上还有其他怪异之处。

重新抛出异常

重新抛出异常语义是获得许多新开发人员的陷阱。

很多时候我看到如下代码

catch(Exception e) 
{
   // Do stuff 
   throw e; 
}

问题在于，它会擦除​​堆栈跟踪，并使诊断问题变得更加困难，导致您无法跟踪异常的起源。

正确的代码是不带参数的throw语句：

catch(Exception)
{
    throw;
}

或者将异常包装在另一个异常中，然后使用内部异常来获取原始堆栈跟踪：

catch(Exception e) 
{
   // Do stuff 
   throw new MySpecialException(e); 
}

海森堡观察窗

如果您正在执行按需加载的东西，这可能会严重地咬住您，例如：

private MyClass _myObj;
public MyClass MyObj {
  get {
    if (_myObj == null)
      _myObj = CreateMyObj(); // some other code to create my object
    return _myObj;
  }
}

现在，假设您在其他地方使用此代码：

// blah
// blah
MyObj.DoStuff(); // Line 3
// blah

现在您要调试CreateMyObj()方法。因此，您在上面的第3行上放置了一个断点，以打算进入代码。出于很好的考虑，您还在上面的行上设置了一个断点_myObj = CreateMyObj();，甚至在CreateMyObj()其内部设置了一个断点。

该代码到达第3行上的断点。您进入该代码。您希望输入条件代码，因为_myObj显然为null，对吗？嗯...所以...为什么跳过条件直接进入return _myObj？您将鼠标悬停在_myObj上……的确，它确实具有价值！那是怎么发生的？！

答案是您的IDE导致它获得了一个值，因为您打开了一个“监视”窗口-尤其是“自动”监视窗口，其中显示了与当前或上一行执行相关的所有变量/属性的值。当你打你的断点在第3行，监视窗口中决定，你有兴趣知道的价值MyObj-所以在幕后，忽略任何断点的，它去和计算的价值MyObj为你- 包括调用CreateMyObj()该设置_myObj的值！

这就是为什么我将其称为“海森堡监视窗口”的原因-您不能在不影响它的情况下观察该值... :)

GOTCHA！

编辑 -我认为@ChristianHayter的评论应包含在主要答案中，因为这似乎是解决此问题的有效方法。因此，只要您拥有延迟加载的属性...

用[DebuggerBrowsable（DebuggerBrowsableState.Never）]或[DebuggerDisplay（“ <按需加载>>”）]装饰属性。–克里斯蒂安·海特（Christian Hayter）

这是另一个让我着迷的时间：

static void PrintHowLong(DateTime a, DateTime b)
{
    TimeSpan span = a - b;
    Console.WriteLine(span.Seconds);        // WRONG!
    Console.WriteLine(span.TotalSeconds);   // RIGHT!
}

TimeSpan.Seconds是时间跨度的秒部分（2分钟和0秒的秒值为0）。

TimeSpan.TotalSeconds是以秒为单位测量的整个时间跨度（2分钟的总秒数为120）。

内存泄漏，因为您没有取消挂钩事件。

这甚至吸引了一些我认识的高级开发人员。

想象一下一个WPF表单，其中包含许多内容，并且您在其中订阅了一个事件。如果您不取消订阅，则在关闭并取消引用后，整个表单将保留在内存中。

我相信我看到的问题是在WPF表单中创建DispatchTimer并订阅Tick事件，如果您不对计时器执行-=则您的表单会泄漏内存！

在此示例中，您的拆卸代码应具有

timer.Tick -= TimerTickEventHandler;

由于您在WPF表单内创建了DispatchTimer的实例，因此这一点特别棘手，因此您会认为这将是垃圾回收过程处理的内部引用...不幸的是DispatchTimer使用了订阅和服务的静态内部列表。在UI线程上请求，因此引用由静态类“拥有”。

也许不是真正的陷阱，因为该行为是用MSDN清楚地编写的，但因为我发现它与直觉相反而使我不知所措：

Image image = System.Drawing.Image.FromFile("nice.pic");

这个家伙将"nice.pic"文件锁定，直到处理完图像为止。当时，我遇到了麻烦，但是尽管可以动态地加载图标会很不错，但一开始并没有意识到我最终得到了数十个打开和锁定的文件！图片跟踪其从中加载文件的位置...

如何解决呢？我以为只有一支班轮能胜任这项工作。我期望有一个额外的参数FromFile()，但没有，所以我写了这个...

using (Stream fs = new FileStream("nice.pic", FileMode.Open, FileAccess.Read))
{
    image = System.Drawing.Image.FromStream(fs);
}

如果您使用ASP.NET，我想说Webforms生命周期对我来说是一个很大的难题。我花了无数小时来调试写得不好的Web表单代码，这是因为许多开发人员实际上并不真正了解何时使用哪个事件处理程序（不幸的是，包括我在内）。

重载==运算符和未类型化的容器（数组列表，数据集等）：

string my = "my ";
Debug.Assert(my+"string" == "my string"); //true

var a = new ArrayList();
a.Add(my+"string");
a.Add("my string");

// uses ==(object) instead of ==(string)
Debug.Assert(a[1] == "my string"); // true, due to interning magic
Debug.Assert(a[0] == "my string"); // false

解决方案？

• string.Equals(a, b)比较字符串类型时始终使用

• 使用泛型就像List<string>确保两个操作数都是字符串一样。

[Serializable]
class Hello
{
    readonly object accountsLock = new object();
}

//Do stuff to deserialize Hello with BinaryFormatter
//and now... accountsLock == null ;)

故事的寓意：反序列化对象时不运行字段初始化程序

DateTime.ToString（“ dd / MM / yyyy”） ; 实际上，这并不总是为您提供dd / MM / yyyy，而是考虑区域设置并根据您所在的位置替换日期分隔符。因此，您可能会得到dd-MM-yyyy或类似内容。

正确的方法是使用DateTime.ToString（“ dd'/'MM'/'yyyy”）;

DateTime.ToString（“ r”）应该转换为使用GMT的RFC1123。GMT距UTC不到一秒钟，但是即使有问题的DateTime指定为Local ，“ r”格式说明符也不会转换为UTC。

这将导致以下问题（取决于您当地时间距UTC的距离而变化）：

DateTime.Parse("Tue, 06 Sep 2011 16:35:12 GMT").ToString("r")
>              "Tue, 06 Sep 2011 17:35:12 GMT"

哎呀！

我前几天看到这则贴子，我觉得它晦涩难懂，对那些不知道的人来说很痛苦

int x = 0;
x = x++;
return x;

因为这将返回0，而不是大多数人期望的1

我参加这个聚会有点晚了，但是最近有两个我都被我咬的陷阱：

日期时间分辨率

“ Ticks”属性的测量时间为百万分之一秒（100纳秒块），但是分辨率不是100纳秒，而是15毫秒。

这段代码：

long now = DateTime.Now.Ticks;
for (int i = 0; i < 10; i++)
{
    System.Threading.Thread.Sleep(1);
    Console.WriteLine(DateTime.Now.Ticks - now);
}

将为您提供（例如）输出：

0
0
0
0
0
0
0
156254
156254
156254

同样，如果您查看DateTime.Now.Millisecond，则将以15.625ms的舍入块形式获取值：15、31、46等。

此特定行为因系统而异，但此日期/时间API中还有其他与分辨率相关的陷阱。

路径组合

组合文件路径的好方法，但并不总是能达到您期望的方式。

如果第二个参数以\字符开头，则不会给出完整的路径：

这段代码：

string prefix1 = "C:\\MyFolder\\MySubFolder";
string prefix2 = "C:\\MyFolder\\MySubFolder\\";
string suffix1 = "log\\";
string suffix2 = "\\log\\";

Console.WriteLine(Path.Combine(prefix1, suffix1));
Console.WriteLine(Path.Combine(prefix1, suffix2));
Console.WriteLine(Path.Combine(prefix2, suffix1));
Console.WriteLine(Path.Combine(prefix2, suffix2));

给您以下输出：

C:\MyFolder\MySubFolder\log\
\log\
C:\MyFolder\MySubFolder\log\
\log\

当您启动一个过程（使用System.Diagnostics）并写入控制台时，但您从未读过Console.Out流，经过一定量的输出后，您的应用程序似乎会挂起。

Linq-To-Sql中没有运算符快捷方式

看这里。

简而言之，在Linq-To-Sql查询的条件子句中，不能使用诸如||和&&避免空引用异常之类的条件快捷方式。即使第一个条件不需要评估第二个条件，Linq-To-Sql也会评估OR或AND运算符的两端！

在虚拟方法中使用默认参数

abstract class Base
{
    public virtual void foo(string s = "base") { Console.WriteLine("base " + s); }
}

class Derived : Base
{
    public override void foo(string s = "derived") { Console.WriteLine("derived " + s); }
}

...

Base b = new Derived();
b.foo();

输出：
派生基数

值可变集合中的对象

struct Point { ... }
List<Point> mypoints = ...;

mypoints[i].x = 10;

没有效果。

mypoints[i]返回Point值对象的副本。C＃很高兴让您修改副本的字段。默默无所事事。

更新： 这似乎已在C＃3.0中修复：

Cannot modify the return value of 'System.Collections.Generic.List<Foo>.this[int]' because it is not a variable

也许不是最坏的情况，但是.net框架的某些部分使用度，而其他部分使用弧度 （并且Intellisense附带的文档从不告诉您哪个，您必须访问MSDN才能找到答案）

所有这些都可以通过上一Angle堂课来避免...

对于C / C ++程序员来说，自然而然地过渡到C＃。但是，我个人遇到的最大难题（并已经看到与其他人进行相同的转换）并不能完全理解C＃中的类和结构之间的区别。

在C ++中，类和结构是相同的。它们仅在默认可见性方面有所不同，其中类默认为私有可见性，而结构默认为公共可见性。在C ++中，此类定义

    class A
    {
    public:
        int i;
    };

在功能上等同于此struct定义。

    struct A
    {
        int i;
    };

但是，在C＃中，类是引用类型，而结构是值类型。这使得一个大的（1）决定何时使用了另一种，（2）测试对象的相等，（3）的性能（例如，装箱/拆箱）等差

网上有各种各样与两者之间的差异有关的信息（例如here）。我强烈鼓励任何向C＃过渡的人至少对差异及其含义有一定的了解。

垃圾回收和Dispose（）。尽管您无需执行任何操作来释放内存，但仍然必须通过Dispose（）释放资源。当您使用WinForms或以任何方式跟踪对象时，这是一件非常容易忘记的事情。

数组工具 IList

但是不要实施它。当您致电添加时，它告诉您它不起作用。那么，为什么一个类在无法支持该接口的情况下实现该接口呢？

编译但不起作用：

IList<int> myList = new int[] { 1, 2, 4 };
myList.Add(5);

我们有很多这个问题，因为串行器（WCF）将所有IList转换为数组，并且会出现运行时错误。

foreach循环变量作用域！

var l = new List<Func<string>>();
var strings = new[] { "Lorem" , "ipsum", "dolor", "sit", "amet" };
foreach (var s in strings)
{
    l.Add(() => s);
}

foreach (var a in l)
    Console.WriteLine(a());

打印五个“ amet”，而以下示例可以正常工作

var l = new List<Func<string>>();
var strings = new[] { "Lorem" , "ipsum", "dolor", "sit", "amet" };
foreach (var s in strings)
{
    var t = s;
    l.Add(() => t);
}

foreach (var a in l)
    Console.WriteLine(a());

MS SQL Server无法处理1753年之前的日期。重要的是，这与.NET DateTime.MinDate常数1/1/1 不同步。因此，如果您试图节省思想，一个格式错误的日期（最近一次在数据导入中发生在我身上）或仅仅是征服者威廉的出生日期，那您就会遇到麻烦了。没有内置的解决方法。如果您可能需要处理1753年之前的日期，则需要编写自己的解决方法。

讨厌的Linq缓存Gotcha

请参阅导致该发现的我的问题以及发现该问题的博客。

简而言之，DataContext保留了您曾经加载的所有Linq-to-Sql对象的缓存。如果其他任何人对您先前加载的记录进行了任何更改，即使您明确地重新加载了该记录，也将无法获取最新数据！

这是因为ObjectTrackingEnabled在DataContext上调用了一个属性，该属性默认为true。如果将该属性设置为false，则每次都会重新加载记录... 但是 ...您无法使用SubmitChanges（）持久保存对该记录的任何更改。

GOTCHA！

我看到Stream.Read上的合同吸引了很多人：

// Read 8 bytes and turn them into a ulong
byte[] data = new byte[8];
stream.Read(data, 0, 8); // <-- WRONG!
ulong data = BitConverter.ToUInt64(data);

这是错误的原因是，Stream.Read它将最多读取指定的字节数，但是即使在流结束之前还有7个字节可用，也可以完全自由地仅读取1个字节。

它看起来像Stream.Write，这无济于事，如果返回无异常，则保证已写入所有字节。上面的代码几乎一直都起作用也无济于事。当然，没有现成的，方便的方法来正确地正确读取N个字节也无济于事。

因此，要塞住漏洞并提高对此的认识，下面是一个正确的方法示例：

    /// <summary>
    /// Attempts to fill the buffer with the specified number of bytes from the
    /// stream. If there are fewer bytes left in the stream than requested then
    /// all available bytes will be read into the buffer.
    /// </summary>
    /// <param name="stream">Stream to read from.</param>
    /// <param name="buffer">Buffer to write the bytes to.</param>
    /// <param name="offset">Offset at which to write the first byte read from
    ///                      the stream.</param>
    /// <param name="length">Number of bytes to read from the stream.</param>
    /// <returns>Number of bytes read from the stream into buffer. This may be
    ///          less than requested, but only if the stream ended before the
    ///          required number of bytes were read.</returns>
    public static int FillBuffer(this Stream stream,
                                 byte[] buffer, int offset, int length)
    {
        int totalRead = 0;
        while (length > 0)
        {
            var read = stream.Read(buffer, offset, length);
            if (read == 0)
                return totalRead;
            offset += read;
            length -= read;
            totalRead += read;
        }
        return totalRead;
    }

    /// <summary>
    /// Attempts to read the specified number of bytes from the stream. If
    /// there are fewer bytes left before the end of the stream, a shorter
    /// (possibly empty) array is returned.
    /// </summary>
    /// <param name="stream">Stream to read from.</param>
    /// <param name="length">Number of bytes to read from the stream.</param>
    public static byte[] Read(this Stream stream, int length)
    {
        byte[] buf = new byte[length];
        int read = stream.FillBuffer(buf, 0, length);
        if (read < length)
            Array.Resize(ref buf, read);
        return buf;
    }

大事记

我从来不明白为什么事件是一种语言功能。它们使用起来很复杂：您需要在调用之前检查null，需要（自己）注销，您无法找到谁进行了注册（例如：我注册了吗？）。为什么事件不只是图书馆中的一门课？基本上是专业的List<delegate>？

今天，我修复了一个长时间未发现的错误。该错误位于用于多线程方案的通用类中，并且使用静态int字段使用Interlocked提供无锁同步。引起该错误的原因是，类型的泛型类的每个实例化都有其自己的静态变量。因此，每个线程都有其自己的静态字段，并且未按预期使用锁。

class SomeGeneric<T>
{
    public static int i = 0;
}

class Test
{
    public static void main(string[] args)
    {
        SomeGeneric<int>.i = 5;
        SomeGeneric<string>.i = 10;
        Console.WriteLine(SomeGeneric<int>.i);
        Console.WriteLine(SomeGeneric<string>.i);
        Console.WriteLine(SomeGeneric<int>.i);
    }
}

打印5 10 5

可枚举可被多次评估

当您有一个惰性枚举的枚举，并且对其进行两次迭代并获得不同的结果时，它会咬您。（或者您得到相同的结果，但不必要地执行两次）

例如，在编写特定测试时，我需要一些临时文件来测试逻辑：

var files = Enumerable.Range(0, 5)
    .Select(i => Path.GetTempFileName());

foreach (var file in files)
    File.WriteAllText(file, "HELLO WORLD!");

/* ... many lines of codes later ... */

foreach (var file in files)
    File.Delete(file);

想象一下当我File.Delete(file)抛出时的惊喜FileNotFound！

这里发生的是，该files枚举对象被迭代了两次（第一次迭代的结果根本不被记住），并且在每个新的迭代中您都将被调用，Path.GetTempFilename()因此您将获得一组不同的临时文件名。

解决方案当然是使用ToArray()或渴望枚举值ToList()：

var files = Enumerable.Range(0, 5)
    .Select(i => Path.GetTempFileName())
    .ToArray();

当您执行多线程操作时，这甚至更可怕：

foreach (var file in files)
    content = content + File.ReadAllText(file);

content.Length在所有写入之后，您仍然发现其为0！然后，您开始严格检查以下情况：....一个小时的浪费之后...您发现这只是您忘记的那小小的可枚举陷阱...。

刚发现一个奇怪的东西让我陷入了调试一段时间：

您可以为可为null的int增加null而不抛出异常，并且该值保持为null。

int? i = null;
i++; // I would have expected an exception but runs fine and stays as null

TextInfo textInfo = Thread.CurrentThread.CurrentCulture.TextInfo;

textInfo.ToTitleCase("hello world!"); //Returns "Hello World!"
textInfo.ToTitleCase("hElLo WoRld!"); //Returns "Hello World!"
textInfo.ToTitleCase("Hello World!"); //Returns "Hello World!"
textInfo.ToTitleCase("HELLO WORLD!"); //Returns "HELLO WORLD!"

是的，该行为已记录在案，但这肯定是不正确的。