我很长一段时间都不知道“as”关键字。

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

如果obj不是MyClass，则第二个将返回null，而不是引发类强制转换异常。

考虑了@dp AnonCast，决定尝试一下。以下是我提出的可能对某些人有用的建议：

// using the concepts of dp's AnonCast
static Func<T> TypeCurry<T>(Func<object> f, T type)
{
    return () => (T)f();
}

下面是它的使用方法：

static void Main(string[] args)
{

    var getRandomObjectX = TypeCurry(GetRandomObject,
        new { Name = default(string), Badges = default(int) });

    do {

        var obj = getRandomObjectX();

        Console.WriteLine("Name : {0} Badges : {1}",
            obj.Name,
            obj.Badges);

    } while (Console.ReadKey().Key != ConsoleKey.Escape);

}

static Random r = new Random();
static object GetRandomObject()
{
    return new {
        Name = Guid.NewGuid().ToString().Substring(0, 4),
        Badges = r.Next(0, 100)
    };
}

我喜欢使用using指令重命名一些类，以便于阅读，如下所示：

// defines a descriptive name for a complexed data type
using MyDomainClassList = System.Collections.Generic.List<
  MyProjectNameSpace.MyDomainClass>;

....


MyDomainClassList myList = new MyDomainClassList();
/* instead of 
List<MyDomainClass> myList = new List<MyDomainClass>();
*/

这对于代码维护也非常方便。如果需要更改类名，只需要更改一个位置。另一个例子：

using FloatValue  = float; // you only need to change it once to decimal, double...

....
FloatValue val1;
...

我还不能发表评论，但请注意，默认情况下，VisualStudio2008会自动跳过财产，因此在这种情况下不再需要DebuggerStepThrough属性。此外，我还没有注意到有人展示如何声明无参数lambda（对于实现Action＜＞很有用）（）=>DoSomething（x）；

你还应该仔细阅读闭包——我不够聪明，无法正确解释它们。但基本上，这意味着编译器做了一些聪明的事情，这样即使在创建lambda之后“超出范围”，这行代码中的x仍然可以工作。

我最近还发现，可以假装忽略lambda参数：（e，_）=>DoSomething（e）

它并不是真的忽略它，只是_是一个有效的标识符。所以你不能像那样忽略这两个参数，但我认为这是一种很好的方式来表明我们不关心这个参数（通常是EventArgs，它是.Empty）。

正在标记我的末端区域。。。

#region stuff1
 #region stuff1a
 //...
 #endregion stuff1a
#endregion stuff1

仅适用于使用扩展方法的引用枚举二进制操作。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace BinaryOpGenericTest
{
    [Flags]
    enum MyFlags
    {
        A = 1,
        B = 2,
        C = 4

    }

    static class EnumExtensions
    {
        private static Dictionary<Type, Delegate> m_operations = new Dictionary<Type, Delegate>();

        public static bool IsFlagSet<T>(this T firstOperand, T secondOperand) 
                                                  where T : struct
        {

            Type enumType = typeof(T);


            if (!enumType.IsEnum)
            {
                throw new InvalidOperationException("Enum type parameter required");
            }


            Delegate funcImplementorBase = null;
            m_operations.TryGetValue(enumType, out funcImplementorBase);

            Func<T, T, bool> funcImplementor = funcImplementorBase as Func<T, T, bool>;

            if (funcImplementor == null)
            {
                funcImplementor = buildFuncImplementor(secondOperand);
            }



            return funcImplementor(firstOperand, secondOperand);
        }


        private static Func<T, T, bool> buildFuncImplementor<T>(T val)
                                                            where T : struct
        {
            var first = Expression.Parameter(val.GetType(), "first");
            var second = Expression.Parameter(val.GetType(), "second");

            Expression convertSecondExpresion = Expression.Convert(second, typeof(int));
            var andOperator = Expression.Lambda<Func<T, T, bool>>(Expression.Equal(
                                                                                                       Expression.And(
                                                                                                            Expression.Convert(first, typeof(int)),
                                                                                                             convertSecondExpresion),
                                                                                                       convertSecondExpresion),
                                                                                             new[] { first, second });
            Func<T, T, bool> andOperatorFunc = andOperator.Compile();
            m_operations[typeof(T)] = andOperatorFunc;
            return andOperatorFunc;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            MyFlags flag = MyFlags.A | MyFlags.B;

            Console.WriteLine(flag.IsFlagSet(MyFlags.A));            
            Console.WriteLine(EnumExtensions.IsFlagSet(flag, MyFlags.C));
            Console.ReadLine();
        }
    }
}