@艾德，我有点不愿意发表这篇文章，因为这只是吹毛求疵。但是，我要指出，在您的代码示例中：

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

如果你要使用“is”，为什么要使用“as”进行安全的转换？如果你确定obj确实是MyClass，一个泥沼标准演员：

c = (MyClass)obj

…永远不会失败。

同样，你可以说：

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

我对.NET的内部结构了解不多，但我的直觉告诉我，这会将最多两个类型转换操作减少到最多一个。无论哪种方式都不太可能打破处理银行；我个人认为，后一种形式看起来也更干净。

使用“throw；”而不是“throw ex；”来保留堆栈跟踪

如果在不添加附加信息的情况下重新抛出异常，请使用“throw”而不是“throw ex”。catch块中的空“throw”语句将发出特定的IL，该IL在保留原始堆栈跟踪的同时重新抛出异常。“throw ex”将丢失对异常原始源的堆栈跟踪。

要使用LINQ测试IEnumerable＜T＞是否为空，请使用：

IEnumerable＜T＞.Any（）；

起初，我使用（IEnumerable＜T＞.Count（）！=0)...这不必要地导致枚举IEnumerable＜T＞中的所有项。作为对此的改进，我继续使用（IEnumerable＜T＞.FirstOrDefault（）==null）。。。哪个更好。。。但是IEnumerable<T>.Any（）是最简洁的，并且性能最好。

我找不到任何使用字符串的人。请使用分隔符连接字符串。每个人都在写同样丑陋的for循环

var sb = new StringBuilder();
var count = list.Count();
for(int i = 0; i < count; i++)
{
  if (sb.Length > 0) sb.Append(seperator);
  sb.Append(list[i]);
}

return sb.ToString();

而不是

return string.Join(separator, list.ToArray());

我想说，将某些系统类用于扩展方法非常方便，例如system.Enum，您可以执行以下操作。。。

[Flags]
public enum ErrorTypes : int {
    None = 0,
    MissingPassword = 1,
    MissingUsername = 2,
    PasswordIncorrect = 4
}

public static class EnumExtensions {

    public static T Append<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType) type | (int)(ValueType) value));
    }

    public static T Remove<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType)type & ~(int)(ValueType)value));
    }

    public static bool Has<T> (this System.Enum type, T value) where T : struct
    {
        return (((int)(ValueType)type & (int)(ValueType)value) == (int)(ValueType)value);
    }

}

...

//used like the following...

ErrorTypes error = ErrorTypes.None;
error = error.Append(ErrorTypes.MissingUsername);
error = error.Append(ErrorTypes.MissingPassword);
error = error.Remove(ErrorTypes.MissingUsername);

//then you can check using other methods
if (error.Has(ErrorTypes.MissingUsername)) {
    ...
}

当然，这只是一个例子——这些方法可能需要更多的工作。。。

定义自定义属性时，可以将其与[MyAttrAttribute]或[MyAttr]一起使用。当两种书写都存在类时，就会发生编译错误。

@特殊字符可用于区分它们：

[AttributeUsage(AttributeTargets.All)]
public class X: Attribute
{}

[AttributeUsage(AttributeTargets.All)]
public class XAttribute: Attribute
{}

[X]      // Error: ambiguity
class Class1 {}

[XAttribute]   // Refers to XAttribute
class Class2 {}

[@X]      // Refers to X
class Class3 {}

[@XAttribute]   // Refers to XAttribute
class Class4 {}