[基础] asp.net 中的一些语法糖（新语法）

1. 自动属性

namespace 新语法
{
    public class Student
    {
        /// <summary>
        ///     1.1 定义一个属性，用于公开给外界访问。
        /// </summary>
        public int StudentNo { get; set; }

        /// <summary>
        ///     编译器语法糖：自动属性。
        /// </summary>
        public string StudentName { set; get; }

        public override string ToString()
        {
            return "StudentNo=" + StudentNo + " StudentName=" + StudentName;
        }
    }
}

2. 隐式类型

             // 隐式类型: var 
            // 1. 隐式类型必须有初始值，否则编译器不能推断出其类型。
            // 2. 类型一旦确定，就不能在赋值其他类型。
            // 3. 只能做方法的局部变量使用。
            // 4. var 不能做形式参数。
            // 5. var 不能复制匿名委托。
            // 7. var 不能赋值为空。
            var student = new Student();
            // 编译器 自动推断其类型。
            int id = student.StudentNo;
            //var varDelegate = delegate() { return 1; }
            //var varNull = null;
            Console.WriteLine(id);            

3. 参数默认值和命名参数

public static void GetDefault()
        {
            DefaultValue();
            DefaultValue("张三");
            // 命名参数的写法
            DefaultValue(age: 50);
        }

        /// <summary>
        ///     参数默认值。注意： Optional parameters must appear after all required parameters.
        /// </summary>
        public static void DefaultValue(string name = "画虎", int age = 100)
        {
            Console.WriteLine("Name=" + name + " Age=" + age);
        }

4. 对象和集合的初始化器

/// <summary>
        /// 对象和集合的初始化器。
        /// </summary>
        public static void ObjectAndListInit()
        {
            // 1. 以前的写法
            Student stu = new Student();
            stu.StudentNo = 001;
            // 2. 使用对象的初始化器的写法。
            Student stu2 = new Student(){StudentNo = 002,StudentName = "王五"};
            // 3.0 集合的初始化器
            List<Student> list0 = new List<Student>()
            {
                new Student(){StudentName = "狼来了",StudentNo = 001},
                new Student(){StudentName = "狼没来",StudentNo = 002}
            };
            // 3.1 以前的写法，其实集合的初始化器通过反编译后的代码和以前的写法一样。
            List<Student> list = new List<Student>();
            list.Add(new Student(){StudentNo = 003,StudentName = "蕾丝"});
        }

5. 匿名类

/// <summary>
        /// 匿名类： vs 语法糖
        /// 1.0 参数个数或参数顺寻不一样会产生一个新的匿名类。
        /// 2.0 参数顺序一样，但类型不一样，二者共用一个匿名类。
        /// </summary>
        public static void AnonymousType()
        {
            // 通过反编译可知，其实它会产生一个参数名称和顺序相同的实体类。其中的属性相当于占位符
            var aType = new {ID=001,Name="西游记"};
        }

6，匿名方法到lambda表达式的演变

/// <summary>
        /// 匿名方法： 匿名委托。
        /// 1. 编译完成后，产生一个私有委托对象，
        /// 2. 生成和1中相同签名的方法
        /// </summary>
        public static void AnonymousMethod()
        {
            // 1.0 利用传统的委托传递方法的方式
            var students = GetStudentList();
            //var whereStudents = students.Where(WhereMethod).ToList();
            //whereStudents.ForEach(ActionWhere);

            // 2.0 利用匿名委托的方式
            //var whereStudents = students.Where(delegate(Student stu) { return stu.StudentNo > 0001; }).ToList();
            //whereStudents.ForEach(delegate(Student stu)
            //{
            //    stu.StudentNo += 1;
            //    stu.StudentName += "(1班)";
            //    Console.WriteLine(stu.ToString());
            //});

            // 3.0 利用lambda表达式
            students.Where(s => s.StudentNo > 0001).ToList().Sort((s1, s2) => s1.StudentNo - s2.StudentNo);
            foreach (Student student in students)
            {
                Console.WriteLine(student.ToString());
            }
        }

        private static bool WhereMethod(Student stu)
        {
            return stu.StudentNo > 0001;
        }

        private static void ActionWhere(Student stu)
        {
            Console.WriteLine(stu.ToString());
        }

        private static List<Student> GetStudentList()
        {
            List<Student> list  = new List<Student>()
            {
               new Student(){StudentName = "zhangshan",StudentNo = 0001},
               new Student(){StudentName = "lisi",StudentNo = 0002},
               new Student(){StudentName = "wangwu",StudentNo = 0003},
               new Student(){StudentName = "laoliu",StudentNo = 0004}
            };
            return list;
        }

 7. 扩展方法

using System;

namespace 新语法
{
    /// <summary>
    ///     扩展方法的特点：
    ///     1. 扩展方法所在类为 (static) 静态方法。
    ///     2. 扩展方法本身为 静态方法
    ///     3. 扩展方法的第一个参数为this，且this 参数不能被out/ref修饰。
    ///     4. 扩展自父类的扩展方法会被子类继承。
    ///     5. 如果扩展方法和实例方法同名，实例方法有更高优先级。
    ///     7. 在使用的类中的命名空间和扩展类说在的命名空间不一致，要先倒入命名空间。
    ///     8. 本质： 就是静态类调用本身对应的静态方法。
    ///     9. 实例方法可以和实例方法构成重载。 
    /// </summary>
    public static class ExtMethodHelper
    {
        public static string DateFormater(this DateTime dt)
        {
            return dt.ToString("yyyy-MM-dd") + " " + dt.DayOfWeek;
        }

        public static string DateFormater(this DateTime dt, string day)
        {
            string dayofweek = dt.DayOfWeek.ToString();
            switch (dayofweek)
            {
                case "Sunday":
                    day = "星期日";
                    break;
            }
            return dt.ToString("yyyy-MM-dd HH:mm:ss") + " " + day;
        }

        public static bool IsNullOrEmputy(this string str)
        {
            return string.IsNullOrEmpty(str);
        }
    }
}

 8. 四个系统内置委托

 public static void SystemDelegate()
        {
            var list = GetStudentList();
            // 1.0 public delegate TResult Func<in T, out TResult>(T arg);
            // 2.0 public delegate void Action<in T>(T obj);
            list.Where(c=>c.StudentName.Contains("z")).ToList().ForEach(c=>Console.WriteLine(c.StudentName));
            // 3.0 public delegate bool Predicate<in T>(T obj);
            Student student = list.Find(c => c.StudentNo == 0001);
            Console.WriteLine("Predicate "+student.StudentName);
            // 3.0 public delegate int Comparison<in T>(T x, T y);
            list.Sort((s1,s2)=>s2.StudentNo-s1.StudentNo);
        }