在FlagAttribute和enum中使用“~”运算符有时我们会将Flag属性与enum一起使用，以对枚举执行逐位操作。

 [Flags]
 public enum Colors
 {
    None  = 0,
    Red   = 1,
    Blue  = 2,
    White = 4,
    Black = 8,
    Green = 16,
    All   = 31 //It seems pretty bad...
 }

注意，enum中选项“All”的值非常奇怪。相反，我们可以使用带有标记枚举的“~”运算符。

 [Flags]
 public enum Colors
 {
    None  = 0,
    Red   = 1,
    Blue  = 2,
    White = 4,
    Black = 8,
    Green = 16,
    All   = ~0 //much better now. that mean 0xffffffff in default.
 }

我想说，将某些系统类用于扩展方法非常方便，例如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)) {
    ...
}

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

关闭

自从匿名委托被添加到2.0之后，我们就能够开发闭包。它们很少被程序员使用，但提供了巨大的好处，如立即代码重用。考虑这段代码：

bool changed = false;

if (model.Prop1 != prop1)
{
    changed = true;
    model.Prop1 = prop1;
}
if (model.Prop2 != prop2)
{
    changed = true;
    model.Prop2 = prop2;
}
// ... etc. 

请注意，上面的if-statements执行类似的代码，只有一行代码除外，即设置不同的财产。这可以通过以下方式缩短，其中变化的代码行作为Action对象的参数输入，适当命名为setAndTagChanged：

bool changed = false;
Action<Action> setAndTagChanged = (action) => 
{ 
    changed = true; 
    action(); 
};

if (model.Prop1 != prop1) setAndTagChanged(() => model.Prop1 = prop1);
if (model.Prop2 != prop2) setAndTagChanged(() => model.Prop2 = prop2);

在第二种情况下，闭包允许您确定lambda中的变化变量的范围，这是解决这个问题的一种简洁方法。

另一种方法是使用另一个未使用的特性，即“或相等”二进制赋值运算符。以下代码显示了如何操作：

private bool conditionalSet(bool condition, Action action)
{
    if (condition) action();
    return condition;
}

// ...

bool changed = false;
changed |= conditionalSet(model.Prop1 == prop1, () => model.Prop1 = prop1);
changed |= conditionalSet(model.Prop2 == prop2, () => model.Prop2 = prop2);

能够使枚举类型具有int以外的值（默认值）

public enum MyEnum : long
{
    Val1 = 1,
    Val2 = 2
}

此外，您可以为该枚举分配任何数值：

MyEnum e = (MyEnum)123;

除了duncansmart的回复，还可以在Framework 2.0上使用扩展方法。只需在System.Runtime.CompilerServices命名空间下添加一个ExtensionAttribute类，就可以使用扩展方法（当然，仅适用于C#3.0）。

namespace System.Runtime.CompilerServices
{
    public class ExtensionAttribute : Attribute
    { 
    }
}

开放泛型是另一个方便的特性，尤其是在使用控制反转时：

container.RegisterType(typeof(IRepository<>), typeof(NHibernateRepository<>));