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

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

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（）构造，在编译时就无法避免这种情况；然而，可以使用反射在运行时调用子类的受保护/私有无参数构造函数来实现这一点。

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

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

我觉得很酷。

要调用基类构造函数，只需将base（）与构造函数内联。要调用基类方法，只需将base.MethodName（）放在派生类方法中

class ClassA 
{
  public ClassA(int a)
  {
    //Do something
  }

  public void Method1()
  {
     //Do Something
  }
}

class ClassB : ClassA
{
  public ClassB(int a) : base(a) // calling the base class constructor
  {
    //Do something
  }

  public void Method2()
  {
    base.Method1();               // calling the base class method
  }
}

当然，只需说出base.MethodName（）就可以调用基类的方法

我最近刚刚学到的一点是，您仍然可以对可为null的值调用方法。。。。

当你有一个可为null的值时：

decimal? MyValue = null;

你可能认为你必须写下：

MyValue == null ? null : MyValue .ToString()

您可以改为写：

MyValue.ToString()

我已经意识到我可以调用MyValue.HasValue和MyValue.Value……但我不能完全调用ToString（）。

下面是C#4.0中字符串类的一个新方法：

String.IsNullOrWhiteSpace(String value)

是时候了。

当您需要（a）在对象之间就事件的发生进行同步通信时，有一个特殊的接口叫做ISynchronizeInvoke。

引用MSDN文章（链接）：

实现此接口的对象可以接收事件发生的通知，并且可以响应有关事件的查询。通过这种方式，客户端可以确保在提交后续请求（取决于第一个请求的完成）之前，已经处理了一个请求。

这里是一个通用包装器：

protected void OnEvent<T>(EventHandler<T> eventHandler, T args) where T : EventArgs
{
    if (eventHandler == null) return;

    foreach (EventHandler<T> singleEvent in eventHandler.GetInvocationList())
    {
        if (singleEvent.Target != null && singleEvent.Target is ISynchronizeInvoke)
        {
            var target = (ISynchronizeInvoke)singleEvent.Target;

            if (target.InvokeRequired) {
                target.BeginInvoke(singleEvent, new object[] { this, args });
                continue;
            }
        }
        singleEvent(this, args);
    }
}

下面是一个示例用法：

public event EventHandler<ProgressEventArgs> ProgressChanged;

private void OnProgressChanged(int processed, int total)
{
    OnEvent(ProgressChanged, new ProgressEventArgs(processed, total));
}