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

第一堂课：

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);
        }
    }
}

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

首先-DebuggerTypeProxy。

[DebuggerTypeProxy(typeof(HashtableDebugView))]
class MyHashtable : Hashtable
{
    private const string TestString = 
        "This should not appear in the debug window.";

    internal class HashtableDebugView
    {
        private Hashtable hashtable;
        public const string TestStringProxy = 
            "This should appear in the debug window.";

        // The constructor for the type proxy class must have a 
        // constructor that takes the target type as a parameter.
        public HashtableDebugView(Hashtable hashtable)
        {
            this.hashtable = hashtable;
        }
    }
}

第二步：

ICustomTypeDescriptor

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

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();

我觉得很酷。

我想很多人都知道C中的指针，但不确定它在C#中是否有效。您可以在不安全的上下文中使用C#中的指针：

static void Main()
{
    int i;
    unsafe
    {               
        // pointer pi has the address of variable i
        int* pi = &i; 
        // pointer ppi has the address of variable pi
        int** ppi = π
        // ppi(addess of pi) -> pi(addess of i) -> i(0)
        i = 0;
        // dereference the pi, i.e. *pi is i
        Console.WriteLine("i = {0}", *pi); // output: i = 0
        // since *pi is i, equivalent to i++
        (*pi)++;
        Console.WriteLine("i = {0}", *pi); // output: i = 1
        // since *ppi is pi, one more dereference  *pi is i 
        // equivalent to i += 2
        **ppi += 2;
        Console.WriteLine("i = {0}", *pi);// output: i = 3
    }
    Console.ReadLine();
}

如果允许第三方扩展，那么C5和Microsoft CCR（请参阅本博客文章了解快速介绍）是必须了解的。

C5补充了.Net有点缺乏的集合库（不是Set？？？），CCR使并发编程更容易（我听说它将与并行扩展合并）。

我喜欢使用using指令重命名一些类，以便于阅读，如下所示：

// defines a descriptive name for a complexed data type
using MyDomainClassList = System.Collections.Generic.List<
  MyProjectNameSpace.MyDomainClass>;

....


MyDomainClassList myList = new MyDomainClassList();
/* instead of 
List<MyDomainClass> myList = new List<MyDomainClass>();
*/

这对于代码维护也非常方便。如果需要更改类名，只需要更改一个位置。另一个例子：

using FloatValue  = float; // you only need to change it once to decimal, double...

....
FloatValue val1;
...