我发现编译器在对外部变量的使用进行编码时遇到了什么样的麻烦，真是难以置信：

string output = "helo world!";
Action action = () => Console.WriteLine(output);
output = "hello!";
action();

这实际上是打印hello！。为什么？因为编译器为委托创建了一个嵌套类，所有外部变量都有公共字段，并在每次调用委托之前插入设置代码：）下面是代码“reflected”：

Action action;
<>c__DisplayClass1 CS$<>8__locals2;
CS$<>8__locals2 = new <>c__DisplayClass1();
CS$<>8__locals2.output = "helo world!";
action = new Action(CS$<>8__locals2.<Main>b__0);
CS$<>8__locals2.output = "hello!";
action();

我觉得很酷。

这与静态构造函数有关。这是一种执行静态销毁的方法（即当程序退出时清理资源）。

第一堂课：

class StaticDestructor
{
    /// <summary>
    /// The delegate that is invoked when the destructor is called.
    /// </summary>
    public delegate void Handler();
    private Handler doDestroy;

    /// <summary>
    /// Creates a new static destructor with the specified delegate to handle the destruction.
    /// </summary>
    /// <param name="method">The delegate that will handle destruction.</param>
    public StaticDestructor(Handler method)
    {
        doDestroy = method;
    }

    ~StaticDestructor()
    {
        doDestroy();
    }
}

然后，作为类的成员，您希望使用“静态析构函数”：

private static readonly StaticDestructor destructor = new StaticDestructor
(
    delegate()
    {
        //Cleanup here
    }
);

现在，当最终垃圾收集发生时，将调用此函数。如果您确实需要释放某些资源，这很有用。

表现出这种行为的快速而肮脏的程序：

using System;

namespace TestStaticDestructor
{
    class StaticDestructor
    {
        public delegate void Handler();
        private Handler doDestroy;

        public StaticDestructor(Handler method)
        {
            doDestroy = method;
        }

        ~StaticDestructor()
        {
            doDestroy();
        }
    }

    class SomeClass
    {
        static SomeClass()
        {
            Console.WriteLine("Statically constructed!");
        }

        static readonly StaticDestructor destructor = new StaticDestructor(
            delegate()
            {
                Console.WriteLine("Statically destructed!");
            }
        );
    }

    class Program
    {
        static void Main(string[] args)
        {
            SomeClass someClass = new SomeClass();
            someClass = null;
            System.Threading.Thread.Sleep(1000);
        }
    }
}

当程序退出时，调用“静态析构函数”。

使用Delegate.CreateDelegate调用私有方法的技巧非常简单。

var subject = new Subject();
var doSomething = (Func<String, String>)
    Delegate.CreateDelegate(typeof(Func<String, String>), subject, "DoSomething");
Console.WriteLine(doSomething("Hello Freggles"));

这是一个有用的上下文

C#中有一些真正隐藏的关键字和特性与TypedReference未记录类相关。以下关键字未记录：

__制造商参考__重新键入__参考值__参数列表

使用示例：

// Create a typed reference
int i = 1;
TypedReference tr1 = __makeref(i);
// Get the type of a typed reference
Type t = __reftype(tr1);
// Get the value of a typed referece
int j = __refvalue(tr1, int); 
// Create a method that accepts and arbitrary number of typed references
void SomeMethod(__arglist) { ...
// Call the method
int x = 1;
string y = "Foo";
Object o = new Object();
SomeMethod(__arglist(x,y,o));
// And finally iterate over method parameters
void SomeMethod(__arglist) {
    ArgIterator ai = new ArgIterator(__arglist);
while(ai.GetRemainingCount() >0)
{
      TypedReference tr = ai.GetNextArg();
      Console.WriteLine(TypedReference.ToObject(tr));
}}

看到上面提到List.ForEach；2.0引入了一系列基于谓词的集合操作-Find、FindAll、Exists等。加上匿名委托，您几乎可以实现3.5的lambda表达式的简单性。

Dictionary.TryGetValue（K键，out V值）

用作支票和支票。而不是

if(dictionary.ContainsKey(key)) 
{
    value = dictionary[key];
    ...
}

你可以这样做；

if(dictionary.TryGetValue(key, out value)) 
{ ... }

并且该值已被设置。