C#学习笔记8

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