很多人不知道的一件事是C#引入的一些预处理器指令。您可以使用#error这是一个错误。生成编译器错误和#warning这是一个警告。

当我使用自上而下的方法进行开发时，我通常使用这些作为“待办事项”列表。我将#error实现此函数，或#warning最终实现此角案例作为提醒。

混合物。基本上，如果您想向多个类添加一个特性，但不能对所有类使用一个基类，请让每个类实现一个接口（没有成员）。然后，为接口编写一个扩展方法，即。

public static DeepCopy(this IPrototype p) { ... }

当然，牺牲了一些清晰度。但它奏效了！

好的，这看起来很明显，但我想提到Object.Equals方法（静态方法，有两个参数）。

我敢肯定，很多人甚至不知道它，或者忘记它就在那里，但在某些情况下，它确实会有所帮助。例如，当您想比较两个对象是否相等时，不知道它们是否为空。你写过多少次这样的东西：

if ((x == y) || ((x != null && y != null) && x.Equals(y)))
{
    ...
}

当你可以写：

if (Object.Equals(x, y))
{
    ...
}

（Object.Equals实际上与第一个代码示例中的实现完全相同）

高级调试

陈列

已经提到的DebuggerDisplay和DebuggerBrowseble属性控制元素的可见性和显示的文本值。简单地重写ToString（）将导致调试器使用该方法的输出。

如果您想要更复杂的输出，可以使用/创建调试器可视化工具这里有。

罢工之子

微软提供了一个名为SOS的调试器扩展。这是一个非常强大（虽然经常令人困惑）的扩展，是诊断“泄漏”的极好方法，更准确地说，对不再需要的对象的不需要的引用。

框架源的符号服务器

遵循这些说明将允许您逐步了解框架某些部分的源代码。

2010年的变化

Visual Studio 2010中有几个增强功能和新功能：

调试并行任务并行堆栈允许同时查看多个线程调用堆栈。历史调试允许您及时查看事件和非本地变量（只要您提前启用集合）。可能会对调试方式产生重大影响。

在.NET 3.5中与lambdas语句一起使用时，Func＜＞类型是绝对的。这些功能允许自定义功能，并且可以很好地帮助用户提供可自定义的对象，而无需对其进行子类化或求助于某些有限的系统，例如跟踪列出用户想要监视的按钮或键的变量。此外，它们可以像常规方法一样被调用，也可以像变量一样被赋值。我能想到的唯一缺点是，你只能有5个论点！尽管到那时你可能想考虑一个不同的解决方案。。。编辑：提供一些示例。

...
public Func<InputHelper, float> _horizontalCameraMovement = (InputHelper input) => 
{
    return (input.LeftStickPosition.X * _moveRate) * _zoom;
}
public Func<InputHelper, float> _verticalCameraMovement = (InputHelper input) => 
{
    return (-input.LeftStickPosition.Y * _moveRate) * _zoom;
}
...
public void Update(InputHelper input)
{
    ...
    position += new Vector2(_horizontalCameraMovement(input), _verticalCameraMovement(input));
    ...
}

在本例中，您可以编写一个函数，该函数执行任意计算并返回一个浮点值，该值将确定相机移动的量。这不是最好的代码，但它可以跨越这一点。

private int foo;
public int FooProperty {
    get
    {
        if (_onFooGotten() == true)
            return _foo;
    }
    set
    {
        if (onFooSet() == true)
            _foo = value;
    }
}
...
public Func<bool> _onFooGotten = () => 
{
    //do whatever...
    return true;
}
public Func<bool> _onFooSet = () =>
{
    //do whatever...
    return true;
}

这并不是最好的例子（因为我还没有真正探讨过这个用法），但它展示了一个使用lambda函数进行快速事件引发的例子，而没有代理的麻烦。编辑：想到了另一个。空值！C#最接近可选参数。

泛型和奇怪的递归模板模式确实有助于一些静态方法/属性声明。

假设您正在构建类层次结构：

class Base
{
}

class Foo: Base
{
}

class Bar: Base
{
}

现在，您需要在类型上声明静态方法，这些方法应该采用相同类型的参数（或返回值）或相同类型的静态财产。例如，您需要：

class Base
{
    public static Base Get()
    {
        // Return a suitable Base.
    }
}

class Foo: Base
{
    public static Foo Get()
    {
        // Return a suitable Foo.
    }
}

class Bar: Base
{
    public static Bar Get()
    {
        // Return a suitable Bar.
    }
}

如果这些静态方法基本上都做相同的事情，那么您手中就有大量重复的代码。一种解决方案是在返回值上删除类型安全，并始终返回Base类型。但是，如果您希望类型安全，那么解决方案是将Base声明为：

class Base<T> where T: Base<T>
{
    public static T Get<T>()
    {
        // Return a suitable T.
    }
}

你Foo和Bar是：

class Foo: Base<Foo>
{
}

class Bar: Base<Bar>
{
}

这样，他们将自动获得静态方法的副本。

将Singleton模式封装在基类中也很神奇（我知道下面的代码不是线程安全的，这只是为了证明一点）：

public class Singleton<T> where T: Singleton<T>, new()
{
  public static T Instance { get; private set; }

  static Singleton<T>()
  {
    Instance = new T();
  }
}

我意识到这迫使您在单例子类上使用一个公共的无参数构造函数，但是如果没有where T:protected new（）构造，在编译时就无法避免这种情况；然而，可以使用反射在运行时调用子类的受保护/私有无参数构造函数来实现这一点。