1.泛型的约束：

（1）接口约束；

（2）基类约束，基类约束必须放在第一（假如有多个约束）；

（3）struct/class约束；

（4）多个参数类型的约束，每个类型参数都要用where关键字；

（5）构造器约束，只能是无参构造器，如new();

（6）约束可以由派生类继承，但必须在派生类中显式地指定这些约束；

（7）泛型方法的约束设置与泛型类的约束设置，是一样的；

2.协变性与逆变性：在泛型中，将一个较具体的类型赋给一个较泛化的类型，即是协变。将一个较泛化的类型赋给一个较具体的类型，即是逆变。

　　协变：在C#4.0中使用out类型参数修饰符允许协变性，该out修饰的类型参数，会导致该类型参数只能用于成员的返回与属性的取值方法，永远不用于输入参数或者属性的赋值方法。

　　逆变：在C#4.0中使用in类型参数修饰符允许逆变性，该in修饰的类型参数，会导致该类型参数只能用于成员的输入（输入参数）与属性的设置方法。

　　如Contact类继承自PdaItem，若对泛型接口（IConvertible<in T1,out T2>）进行了协变与逆变的设置，就可以成功地从一个IConvertible<PdaItem,Contact>转换成一个IConvertible<Contact,PdaItem>。

综上所述：协出逆进。

3.数组本身是支持协变与逆变，如PdaItem[] pdaItems=new Contact[]{}，Contact[] pdaItems=(Contact)new PdaItem[]{}。

4.委托概述：长期以来经验丰富的C、C++程序员利用方法指针，将可执行的步骤（方法）作为参数传递给另一个方法。C#使用委托来提供相同的功能，它将方法作为对象封装起来，允许在运行时间接绑定一个方法的调用，可查看DelegateSample类的代码。

5.委托的定义：C#将所有委托的定义成间接派生于System.Delegate，其继承层次为Object -> Delegate ->MulticastDelegate -> 自定义委托。当然我们使用关键delegate声明，其在编译后生成的CIL代码，就是自动继承上面的结构，因此我们不能手动显式继承委托。在委托实例化中，从C@2.0开始可以不使用new来手工创建，直接赋值相同的签名方法即可，编译器会在编译过程中会自动根据委托推断，自动添加new创建，以及把方法名称作为委托参数传递也是一样，

6.系统自定义的委托：在.net3.5（C#3.0）中加入了Action与Func这个两个泛型委托，前者是没有返回值的委托，后者是有返回值的委托，在.Net4.0（C#4.0）中又在这些泛型委托中加入了in(逆变)/out(协变)的功能。这些委托的定义省略了我们手工进行自定义委托的情况，因为这些泛型委托都涵盖了我们可能遇到的所有使用情况。（除非你要定义一个有特殊含义的委托名称）。

7.委托使用可变性，即委托类型参数的可变性（协变与逆变），可查看DelegateSample.CovariantAndContravariant()方法的代码。

8.Lambda表达式：Lambda表达式是匿名函数的简洁表达形式，Lambda表达式包含语句Lambda与表达式Lambda，前者可以含有多个语句的语句块（一般只使用两三条语句），后者只有一句表达式。

9.使用Lambda表达式注意事项：

（1）Lambda表达式本身是无类型，只有赋值给一个委托，Lambda表达式就表现为有一个类型，就是该方法签名的委托。

（2）因Lambda表达式是无类型的，所以也就不能赋值给隐式类型的局部变量。

（3）如果目的地在Lambda表达式的外部，C#就不允许在匿名函数内部使用跳转语句（break、goto、continue），类似的，不能从Lambda表达式外部跳入Lambda表达式内部。

（4）对于在Lambda表达式内部引入的变量，其作用域仅限于Lambda表达式主体。

（5）编译器的程序执行流程分析机制检测不到在Lambda表达式内部初始化局部变量的情况。

　　以上的注意事项的代码实例，可以查看DelegateSample.NoticeMatter()方法。

10.Lambda表达式并非CLR内部的固有构造，它们的实现是由C#编译器在编译时生成的，编译器会自动把Lambda表达式生成为一个当前类的内部方法（静态或实例方法），其方法名是编译器自动处理（其一般含有anonymous等字眼的描述）。

11.在匿名函数中使用外部局部变量，编译器会把这些外部变量生成为当前类的嵌套类（sealed闭包）的公共字段，其嵌套类中含有公共字段与对应的匿名名称方法，因此这些局部变量变成了嵌套的成员，其生命周期也就被延长了。通过查看ILdasm（中间语言反编译，能够查看类库编译后的中间语言，VS工具自带）。也可查看DelegateSample.AscendingAndTimeOfCompiler()与_LocalDisplayClass_00001嵌套类。

12.表达式树：“解释”是C#引入表达式树这一概念的重要动机，如果一种Lambda表达式代表的是与表达式有关的数据，而不是编译好的代码（匿名函数与委托），这种Lambda表达式就是“表达式树”。由于表达式树代表的是数据而非编译好的代码，所以可以把数据转换成一种替代格式。

　　例如，可以把它从表达式数据转换成在数据库中执行的SQL代码。如IQueryable接口中含有表达式树类型、查询供应者、查询返回的类型，只要实现该接口就能对特定的数据源进行查询操作，期内包含需要自定义解析表达式树的指令。所有表达式树的类型（如ParameterExpression、BinaryExpression、MethodCallExpression），都是从Expression继承。

13.Lambda表达式和表达式树的比较：无论是用于委托的Lambda表达式，还是用于表达式树的Lambda表达式都会被编译，而且在这两种情况下，表达式的语法都会在编译时进行完整的语义分析验证。但是，两者的区别在于，Lambda表达式在CIL中遍编译成委托，而表达式树被编译成System.Linq.Expressions.Expression类型的一个数据结构。可查看AnalysisExpression类的代码，以及Output()方法输出的数据内容。

14.一个表达式树是由零个或者多个其他表达式树构成的，被包含的表达式树存储在Expression的Body属性中。通常，语句Lambda和表达式Lambda可以互换使用，然而，不能将语句Lambda转换成“表达式树”，只能使用表达式Lambda语法来表示“表达式树”。

public class DelegateSample
{
    //冒泡排序，基本排序处理
    public static void BubbleSort<TSource>(TSource[] items, Func<TSource, TSource, bool> predicate) where TSource : IComparable<TSource>, IEquatable<TSource>
    {
        if (items == null || items.Length < 2)
        {
            return;
        }
        TSource tempItem;
        /*第一种算法，定点比较
        for (int i = 0; i < items.Length; i++)
        {
            for (int j = i; j < items.Length; j++)
            {
                if (predicate(items[i], items[j]))
                {
                    tempItem = items[i];
                    items[i] = items[j];
                    items[j] = tempItem;
                }
            }
        }*/
        //第二种算法，逐一比较
        for (int i = items.Length - 1; i >= 0; i--)
        {
            for (int j = 1; j <= i; j++)
            {
                if (predicate(items[j - 1], items[j]))
                {
                    tempItem = items[j - 1];
                    items[j - 1] = items[j];
                    items[j] = tempItem;
                }
            }
        }
    }

    public static void Ascending()
    {
        int[] items = new int[] { 3, 2, 1, 4, 6, 5 };
        Console.WriteLine("升序前");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        BubbleSort(items, (first, second) => first > second);
        Console.WriteLine("\n升序后");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
    }

    public static void Descending()
    {
        int[] items = new int[] { 3, 2, 1, 4, 6, 5 };
        Console.WriteLine("降序前");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        BubbleSort(items, (first, second) => first < second);
        Console.WriteLine("\n降序后");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
    }
    //按字母排序
    public static void AlphabeticalGreaterThan()
    {
        int[] items = new int[] { 1, 12, 13, 5, 4, 6 };
        Console.WriteLine("排序前");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        BubbleSort(items, (first, second) =>
        {
            int comparison = first.ToString().CompareTo(second.ToString());
            return comparison > 0;
        });
        Console.WriteLine("\n排序后");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
    }
    //委托的协变与逆变
    public static void CovariantAndContravariant()
    {
        //逆变
        Action<object> broadAction = delegate (object data) { Console.WriteLine(data); };
        Action<string> narrowAction = broadAction;

        //协变
        Func<string> narrowFunction = () => Console.ReadLine();
        Func<object> broadFunction = narrowFunction;

        //协变与逆变
        Func<object, string> func1 = (data) => data.ToString();
        Func<string, object> func2 = func1;
    }
    //Lambda表达式注意事项
    public static void NoticeMatter()
    {
        //错误：控制权不能离开Lambda表达式的主体。
        /*string[] args;
        Func<string> expression;
        switch (args[0])
        {
            case "/File":
                expression = () =>
                {
                    if (!File.Exists(args[1]))
                    {
                        break;
                    }
                    //...
                    return args[1];
                };
                //...
        }*/

        //不能在Lambda表达式内部进行初始化局部变量。
        /*int number;
        Func<string, bool> expression = text => int.TryParse(text, out number);
        if (expression("1"))
        {
            //错误：使用未赋值的局部变量
            Console.WriteLine(number);
        }

        int number:
        Func<int, bool> isFortyTwo = x => 42 == (number = x);
        if (isFortyTwo(42))
        {
            //错误：使用未赋值的局部变量
            Console.WriteLine(number);
        }*/
    }

    //升序，并记录其比较的次数,编译前
    public static void AscendingAndTime()
    {
        int comparisonCount = 0;
        int[] items = new int[] { 3, 2, 1, 4, 6, 5 };
        Console.WriteLine("升序前");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        BubbleSort(items, (first, second) =>
        {
            comparisonCount++;
            return first > second;
        });
        Console.WriteLine("\n升序后");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        Console.WriteLine("\n比较的次数 {0}", comparisonCount);
    }

    //升序，并记录其比较的次数，编译后
    public static void AscendingAndTimeOfCompiler()
    {
        _LocalDisplayClass_00001 locals = new _LocalDisplayClass_00001();
        locals.comparisonCount = 0;
        int[] items = new int[] { 3, 2, 1, 4, 6, 5 };
        Console.WriteLine("升序前");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        BubbleSort(items, locals._AnonymousMethod_000000);
        Console.WriteLine("\n升序后");
        foreach (var item in items)
        {
            Console.Write("{0}\t", item);
        }
        Console.WriteLine("\n比较的次数 {0}", locals.comparisonCount);
    }

    private sealed class _LocalDisplayClass_00001
    {
        public int comparisonCount;

        public bool _AnonymousMethod_000000(int first, int second)
        {
            comparisonCount++;
            return first > second;
        }
    }
}

public class AnalysisExpression
{
    //输出表达式树的数据结构
    public void Output()
    {
        Expression<Func<int, int, bool>> expression = (x, y) => x > y;
        Console.WriteLine("------------{0}------------", expression);
        PrintNode(expression.Body, 0);
        Console.WriteLine("\n");
        expression = (x, y) => x * y > x + y;
        Console.WriteLine("------------{0}------------", expression);
        PrintNode(expression.Body, 0);
        Console.WriteLine("\n");
    }
    //打印表达式树节点，一般表达式树
    private void PrintNode(Expression expression, int indent)
    {
        if (expression is BinaryExpression)
        {
            PrintNode(expression as BinaryExpression, indent);
        }
        else
        {
            PrintSingle(expression, indent);
        }
    }
    //打印表达式树节点，二元表达式树
    private void PrintNode(BinaryExpression expression, int indent)
    {
        //表达式树是一个数据集合，而通过遍历数据，就可以将数据转换成另一种格式。此处将数据直接转换成对应的文本，然而，具体如何对数据进行解释，完全是开发者自己决定。
        PrintNode(expression.Left, indent + 1);
        PrintSingle(expression, indent);
        PrintNode(expression.Right, indent + 1);
    }
    //打印单个表达式树节点内容
    private void PrintSingle(Expression expression, int indent)
    {
        Console.WriteLine("{0," + indent * 5 + "}{1}", "", NodeToString(expression));
    }
    //节点转到字符
    private string NodeToString(Expression expression)
    {
        string content;
        switch (expression.NodeType)
        {
            case ExpressionType.Multiply:
                content = "*";
                break;
            case ExpressionType.Add:
                content = "+";
                break;
            case ExpressionType.Divide:
                content = "/";
                break;
            case ExpressionType.Subtract:
                content = "-";
                break;
            case ExpressionType.GreaterThan:
                content = ">";
                break;
            case ExpressionType.LessThan:
                content = "<";
                break;
            default:
                content = string.Format("{0}({1})", expression, expression.NodeType);
                break;
        }
        return content;
    }
}