我在使用ReSharper时选择了这个：

隐式方法组转换

//If given this:
var myStrings = new List<string>(){"abc","def","xyz"};
//Then this:
myStrings.ForEach(s => Console.WriteLine(s));
//Is equivalent to this:
myStrings.ForEach(Console.WriteLine);

有关详细信息，请参阅“C#中的隐式方法组转换”。

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

String.IsNullOrWhiteSpace(String value)

是时候了。

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

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

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

不指定数组元素类型的数组初始化：

var pets = new[] { "Cat", "Dog", "Bird" };

条件字符串。格式：

根据数字是正、负还是零，对数字应用不同的格式。

string s = string.Format("{0:positive;negative;zero}", i);

e.g.

string format = "000;-#;(0)";

string pos = 1.ToString(format);     // 001
string neg = (-1).ToString(format);  // -1
string zer = 0.ToString(format);     // (0)

如果您试图从项目列表中创建逗号分隔的字符串：

string[] itemList = { "Example 1", "Example 2", "Example 3" };
CommaDelimitedStringCollection commaStr = new CommaDelimitedStringCollection();
commaStr.AddRange(itemList);
//outputs Example 1,Example 2,Example 3

看看这里的另一个例子。