Action和Func委托助手与lambda方法结合使用。我将这些用于需要委托以提高可读性的简单模式。例如，一个简单的缓存模式是检查请求的对象是否存在于缓存中。如果它确实存在：返回缓存的对象。如果不存在，则生成新实例，缓存新实例并返回新实例。我可以编写一个简单的模式方法，比如这样。。。

private static T CachePattern<T>(string key, Func<T> create) where T : class
{
    if (cache[key] == null)
    {
        cache.Add(key, create());
    }

    return cache[key] as T;
}

…然后，通过在自定义缓存管理器中使用以下内容，我可以大大简化缓存获取/设置代码

public static IUser CurrentUser
{
    get
    {
        return CachePattern<IUser>("CurrentUserKey", () => repository.NewUpUser());
    }
}

现在，简单的“日常”代码模式可以编写一次，并且可以更容易地重用IMHO。我不必编写委托类型，也不必弄清楚我想如何实现回调等。如果我能在10秒内编写它，我就不太适合于剪切/粘贴简单的代码模式，无论它们是懒惰初始化还是上面显示的其他示例。。。

根据周围类的泛型类型分离静态字段。

    public class StaticConstrucEx2Outer<T> {

 // Will hold a different value depending on the specicified generic type
 public T SomeProperty { get; set; }

 static StaticConstrucEx2Outer() {
  Console.WriteLine("StaticConstrucEx2Outer " + typeof(T).Name);
 }

 public class StaticConstrucEx2Inner<U, V> {

  static StaticConstrucEx2Inner() {

   Console.WriteLine("Outer <{0}> : Inner <{1}><{2}>",
    typeof(T).Name,
    typeof(U).Name,
    typeof(V).Name);
  }

  public static void FooBar() {}
 }

 public class SCInner {

  static SCInner() {
   Console.WriteLine("SCInner init <{0}>", typeof(T).Name);
  }

  public static void FooBar() {}
 }
}


StaticConstrucEx2Outer<int>.StaticConstrucEx2Inner<string, DateTime>.FooBar();
StaticConstrucEx2Outer<int>.SCInner.FooBar();

StaticConstrucEx2Outer<string>.StaticConstrucEx2Inner<string, DateTime>.FooBar();
StaticConstrucEx2Outer<string>.SCInner.FooBar();

StaticConstrucEx2Outer<string>.StaticConstrucEx2Inner<string, Int16>.FooBar();
StaticConstrucEx2Outer<string>.SCInner.FooBar();

StaticConstrucEx2Outer<string>.StaticConstrucEx2Inner<string, UInt32>.FooBar();

StaticConstrucEx2Outer<long>.StaticConstrucEx2Inner<string, UInt32>.FooBar();

将产生以下输出

Outer <Int32> : Inner <String><DateTime>
SCInner init <Int32>

Outer <String> : Inner <String><DateTime>
SCInner init <String>

Outer <String> : Inner <String><Int16>

Outer <String> : Inner <String><UInt32>

Outer <Int64> : Inner <String><UInt32>

我个人最喜欢的两个，我很少使用：

代码段（尤其是针对财产的代码段，这在Visual Studio 2008中做得更好）过时属性

避免检查空事件处理程序

在声明时向事件添加一个空委托，在调用事件之前不必总是检查事件是否为null，这是非常棒的。例子：

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

让你这样做

public void DoSomething()
{
    Click(this, "foo");
}

而不是这样

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

另请参阅埃里克·里佩尔（Eric Lippert）关于此主题的相关讨论和博客文章（以及可能的缺点）。

Object.ReferenceEquals方法

确定指定的Object实例是否为同一实例。

参数：

objA:System.Object-要比较的第一个对象。objB:System.Object-要比较的第二个对象。

例子：

 object o = null;
 object p = null;
 object q = new Object();

 Console.WriteLine(Object.ReferenceEquals(o, p));
 p = q;
 Console.WriteLine(Object.ReferenceEquals(p, q));
 Console.WriteLine(Object.ReferenceEquals(o, p));

与“==”和“.Equals”的差值：

基本上，对象A的Equal（）测试与对象B具有相同的内容。

System.Object.ReferenceEquals（）方法始终比较引用。尽管类可以为相等运算符提供自己的行为（下面），如果调用了该运算符，则不会调用该重新定义的运算符通过对System.Object的引用。

对于字符串，实际上没有什么区别，因为==和Equals都已被重写以比较字符串的内容。

另请参见另一个问题的答案（“如何在没有无限递归的情况下检查'=='运算符重载中的空值？”）。

完全访问调用堆栈：

public static void Main()
{
  StackTrace stackTrace = new StackTrace();           // get call stack
  StackFrame[] stackFrames = stackTrace.GetFrames();  // get method calls (frames)

  // write call stack method names
  foreach (StackFrame stackFrame in stackFrames)
  {
    Console.WriteLine(stackFrame.GetMethod().Name);   // write method name
  }
}

所以，如果你选择第一个-你知道你在哪个函数中。如果你正在创建一个助手跟踪函数-在最后一个之前选择一个-你就会知道你的调用者。