我学到的一件有趣的事情是，框架和C#语言的不同部分是在不同的时间编写的，因此不一致。例如，框架本身违反了许多FxCop规则，因为在编写框架时，这些规则并没有全部到位。

此外，using语句旨在使“范围”分离，而不是专门用于处理资源。它是在lock语句之后编写的。埃里克·冈纳森（Eric Gunnerson）曾提到，如果使用语句首先出现，他们可能不需要编写锁语句（尽管谁知道，也许他们无论如何都会有），因为使用语句可能已经足够了。

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

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

定义自定义属性时，可以将其与[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 {}

很抱歉这么晚才发布，我是Stack Overflow的新手，因此错过了之前的机会。

我发现EventHandler＜T＞是该框架的一个很好的功能，但未得到充分利用。

我遇到的大多数C#开发人员在定义自定义事件时仍然会定义自定义事件处理程序委托，这不再是必要的。

而不是：

public delegate void MyCustomEventHandler(object sender, MyCustomEventArgs e);

public class MyCustomEventClass 
{
    public event MyCustomEventHandler MyCustomEvent;
}

你可以去：

public class MyCustomEventClass 
{
    public event EventHandler<MyCustomEventArgs> MyCustomEvent;
}

这要简洁得多，而且您不会陷入这样的两难境地：是将委托放在包含事件的类的.cs文件中，还是EventArgs派生类中。

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

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();
        }
    }
}

恶劣的目标

每个人都看过。基本上，当您看到以下内容时：

[assembly: ComVisible(false)]

该属性的“assembly:”部分是目标。在这种情况下，该属性将应用于程序集，但还有其他属性：

[return: SomeAttr]
int Method3() { return 0; } 

在此示例中，属性应用于返回值。