zoukankan      html  css  js  c++  java
  • MVC基础知识 – 2.新语法

    1.自动属性 Auto-Implemented Properties

    2.隐式类型 var

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

    4.对象初始化器 与 集合初始化器 { }

    5.匿名类 & 匿名方法

    6.扩展方法

    7.系统内置委托 Func / Action  Predicate (bool (T)) / Comparison (int (T,T))

         7.1.Action<T>(无返回类型)

          7.2.Predicate<T>(返回boolen类型)

         7.3.Comparison<int (T,T)> 返回int类型

          7.4.Func<T,TResult>  返回自定义TResult类型

          7.5 Func<T,TResult> + 匿名类

    8.Lambda表达式

    9.标准查询运算符 Standard query operator

          9.1.标准查询运算符: 定义在System.Linq.Enumerable类中的50多个为IEnumerable<T>准备的扩展方法,这些方法用来对它操作的集合进行查询筛选.

         9.2.标准查询运算符 - 分页 Skip().Take()

    10.LINQ查询表达式

     

    1.自动属性

    回顾传统属性概念

    属性的目的:封装字段,控制 1.读写权限 及 2.字段的访问规则(如:年龄范围)。

    但平时,主要是用来封装 读写权限。

    回顾 语法:缺点,臃肿,代码难看!麻烦!

    int id; //字段

    public int Id //属性

    {

      get { return id; }

      set { id = value; }

    }

    自动属性 语法:只需要定义 无实现的属性语法 即可,不需要定义字段。

    public int Id { get; set; }

    public int Age { get; set; }

    public string Name { get; set; }

    2.隐式类型 var

    回顾,传统变量定义方式:

    int age = 11;//传统方式

    隐式类型:在初始化时,就已经根据 = 右边的 值 确定了 var变量的类型了。

    var age1 =12;

    //age1="123";

    var name = "哈哈哈";

    var dog = new Dog();

    age1 = 123;

    name = "刘德华";

    dog.Id = 11;

    编译时,已经 把var 转成了 相应的类型了。

    注意:

    1.声明的同时必须初始化,因为编译时要根据初始化值类型来推断var;

    2.声明后不能修改数据类型,因为初始化时已经确定了var类型了;

    3.只能作为方法局部变量使用。类的成员字段、方法的形参和返回值都不能使用!因为无法编译时确定他们的类型!

    4.初始化表达式不能是匿名函数和null。

    查看源码:var 已经不存在了,都被替换成了 初始化值 的 类型。

    wps_clip_image-11018

     

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

    参数默认值

    static void TestDefault(int age = 25, string name = "TangSan")
    {
    Console.WriteLine(string.Format("{0}的年龄为{1}", name, age));
    }

    测试值

    TestDefault();          //TangSan的年龄为25
    TestDefault(27); //TangSan的年龄为27
    TestDefault(22, "Liu"); //Liu的年龄为22
     
    问题:不给age赋值,直接给name赋值。
     


    命名参数

    TestDefault(name: "命名参数");//命名参数的年龄为25
     
    4.对象初始化器 与 集合初始化器 { }
    /// <summary>
    /// 集合初始化器
    /// </summary>
    static void TestInitialCollection()
    {
    List<Dog> list = new List<Dog>{
    new Dog(){ Id=1, Name="Ruiky1", Age=11, },
    new Dog(){ Id=2, Name="Ruiky2", Age=12, },
    new Dog(){ Id=3, Name="Ruiky3", Age=13, },
    new Dog(){ Id=4, Name="Ruiky4", Age=14, },
    new Dog(){ Id=5, Name="Ruiky5", Age=15, }
    };

    foreach (var item in list)
    {
    Console.WriteLine(
    string.Format("ID号:{0},名称Name:{1},年龄Age:{2}.",item.Id,item.Name,item.Age));
    }
    }
    image

    查看源码:可以看到,编译器帮我们实例化的集合或者数组,并创建了元素对象,设置给数组或集合。

    image
    image

     

    5.匿名类 & 匿名方法

    匿名类

    var obj = new
    {
    Id = 1,
    Name = "Ruiky",
    Age = 2
    };

    在编译后会生成一个【泛型类】,包含:

    a. 获取所有初始值的构造函数,顺序与属性顺序一样;

    b.公有的只读属性,属性不能为null/匿名函数/指针;

    c.属性的私有只读字段;

    d.重写的Equals,GetHashCode,ToString()方法

    用处

    a.避免过度的数据累积
    b.为一种情况特别进行的数据封装 
    c.避免进行单调重复的编码

    注意:匿名类的属性是只读的 –可放心传递,可用在线程间共享数据

    匿名方法

    函数式编程的最大特点之一:把方法作为参数和返回值。 DGShowMsg -> MulticastDelegate(intPtr[]) -> Delegate(object,intPtr)
    匿名方法:编译后会生成委托对象,生成方法,然后把方法装入委托对象,最后赋值给 声明的委托变量。
    匿名方法可以省略参数:编译的时候 会自动为这个方法 按照 委托签名的参数 添加参数

    delegate void DGTest(string str);
    static void InvokeMethod(DGTest dg)
    {
    dg("匿名方法!");
    }

    测试

    InvokeMethod(delegate(string str)
    {
    Console.WriteLine("参数:" + str );
    }); //匿名方法

    image[2]

     

    6.扩展方法

    image

    另外写一个类,(扩展方法)

    image

    image

    调用TestExtensionMethod

    image

     

    7.系统内置委托 Func / Action     Predicate (bool (T)) / Comparison (int (T,T))

    image

    7.1.Action<T>(无返回类型)

     

    7.2.Predicate<T>(返回boolen类型)

    static List<Dog> GetDogList()
            {
                return new List<Dog>(){
                   new Dog(){Age=1,Name="小白1"},
                   new Dog(){Age=2,Name="小黑2"},
                   new Dog(){Age=3,Name="小花3"}
               };
            }

    先给List<T>定义一个扩展方法

    public static void DeleteItem<T>(this List<T> list, Predicate<T> predicateWhere)
            {
                List<T> updateitems = new List<T>();
                //遍历数据集合,根据条件找到要修改的元素 添加到元素集合中
                foreach (T item in list)
                {
                    //根据传入的条件,找到要删除的元素
                    if (predicateWhere(item))
                    {
                        updateitems.Add(item);
                    }
                }
     
                //遍历要删除的元素,在集合中删除
                foreach (T updates in updateitems)
                {
                    list.Remove(updates);
                }
            }

    然后调用

    List<Dog> list = GetDogList();
                //list.ForEach(new Action<Dog>( d => { Console.WriteLine(d.Name + "," + d.Age); }));
                //list.ForEach(new Action<Dog>(delegate(Dog d) { Console.WriteLine(d.Name + "," + d.Age); }));
                //Console.WriteLine("----");
                //直接传方法
                list.ForEach(delegate(Dog d) { Console.WriteLine(d.Name + "," + d.Age); });
                Console.WriteLine("----");
                list.DeleteItem<Dog>(delegate(Dog d) { return d.Age > 1; });
                list.ForEach(delegate(Dog d) { Console.WriteLine(d.Name + "," + d.Age); });

    image

    调用扩展方法 DeleteItem<T>过程

    111

    7.3.Comparison<int (T,T)> 返回int类型

    image

    static void SortByInterface()
            {
                List<Dog> list = GetDogList();
                list.Sort(new Comparison<Dog>(
                    delegate(Dog x, Dog y){ return y.Age - x.Age; })
                );
                list.ForEach(delegate(Dog d) { Console.WriteLine(d.Name + "," + d.Age); });
            }

    image

     

    7.4.Func<T,TResult>  返回自定义TResult类型

    7.4.1 定义一个SmallDog,只有Name参数

    class SmallDog
    {
    public string Name { get; set; }
    }

    7.4.2 将Dog转换成SmallDog.

    static void TestFunc()
    {
    List<Dog> list = GetDogList();
    //将Dog转换成SmallDog.
    IEnumerable<SmallDog> list2 = list.Select(new Func<Dog, SmallDog>(
    delegate(Dog d) { return new SmallDog() { Name = d.Name }; }
    ));//.ToList();

    foreach (var item in list2)
    {
    Console.WriteLine(item.Name);
    }

    //list2.ForEach(delegate(SmallDog d) { Console.WriteLine(d.Name); });
    }

    image

     

    7.5 Func<T,TResult>+匿名类

    /// <summary>
    /// Func + 匿名类<in T,out TResult>
    /// </summary>
    static void TestFuncAnonyClass()
    {
    List<Dog> list = GetDogList();
    //将Dog转换成SmallDog.
    var list2 = list.Select(
    delegate(Dog d) { return new { Name = d.Name, Date = DateTime.Now }; }
    );
    foreach (var item in list2)
    {
    Console.WriteLine(item.Name + "," + item.Date);
    }
    }

    image

     

    8.Lambda表达式

    语句Lambda 和 表达式Lambda 的区别在于,前者在 =>右边有一个语句块(大括号),而后者只有一个表达式(没有return 和大括号)
    Lambda本身无类型,所以不能赋值给 var 变量。 编译时会生成一个静态方法,然后再实例化成委托传递使用.

    List<Dog> list = GetDogList();
    //list.FindAll(delegate(Dog d) { return d.Id > 2; });
    //1.表达式 Lambda
    list.FindAll(d => d.Id > 2);// goes to
    list.ForEach(d => Response.Write(d.ToString() + "<br/>"));

    //2.语句 Lambda
    list.ForEach(d => { if (d.Id > 2) Response.Write(d.ToString() + "<br/>"); });

    image

    演化过程

    image

     

    9.标准查询运算符 Standard query operator

    9.1.标准查询运算符: 定义在System.Linq.Enumerable类中的50多个为IEnumerable<T>准备的扩展方法,这些方法用来对它操作的集合进行查询筛选.

    筛选集合Where:需要提供一个带bool返回值的“筛选器”,从而表明集合中某个元素是否应该被返回。
    查询投射,返回新对象集合 IEnumerable<TSource> Select()
    统计数量int Count()
    多条件排序 OrderBy().ThenBy().ThenBy()
    集合连接 Join()
    ......

    重新写一个GetDogList

    static List<Dog> GetDogList()
    {
    return new List<Dog>(){
    new Dog(){ Id=1, Age=10,Name="小白1", Gender=false},
    new Dog(){Id=2,Age=9,Name="小黑2", Gender=true},
    new Dog(){Id=3,Age=14,Name="小花3", Gender=false},
    new Dog(){Id=4,Age=3,Name="小黄4", Gender=true},
    new Dog(){Id=5,Age=7,Name="小白5", Gender=true}
    };
    }

    在Dog类添加

    using System;


    namespace NewGrammar
    {
    public class Dog
    {
    public int Id { get; set; }
    public int Age { get; set; }
    public string Name { get; set; }

    /// <summary>
    /// 性别
    /// </summary>
    public bool Gender { get; set; }

    public override string ToString()
    {
    return Id + "," + Name + "," + Age + "," + Gender;
    }

    }
    }

    Where和Select

    /// <summary>
    /// 标准查询运算符 - Select 投射方法(返回一个 新的集合)
    /// </summary>
    static void testSQOSelect()
    {
    List<Dog> list = GetDogList();
    List<SmallDog> small = list.Where(d => d.Gender == false)
    .Select(d => new SmallDog() { Name = d.Name }).ToList();

    small.ForEach(d=> Console.WriteLine(d.Name));
    }

    image

    orderby

    /// <summary>
    /// 标准查询运算符 - OrderBy 投射方法(返回一个 新的集合)
    /// </summary>
    static void testSQOOrderBy()
    {
    List<Dog> list = GetDogList();
    List<Dog> small = list.OrderBy(d => d.Age).ToList();

    small.ForEach(d => Console.WriteLine(d.ToString()));
    }

    image

    在GetDogList方法里添加一条数据,年龄和ID2相同

    new Dog(){Id=6,Age=9,Name="小黑2", Gender=true},

    image
    加一个ThenBy
    /// <summary>
    /// 标准查询运算符 - OrderBy 投射方法(返回一个 新的集合)
    /// </summary>
    static void testSQOOrderBy()
    {
    List<Dog> list = GetDogList();
    List<Dog> small = list.OrderBy(d => d.Age).ThenBy(d=>d.Id).ToList();

    small.ForEach(d => Console.WriteLine(d.ToString()));
    }

    image

     

    9.2.标准查询运算符 - 分页

    /// <summary>
    /// 标准查询运算符 - 分页
    /// </summary>
    static void TestPage()
    {
    var pageOne = GetPageListByIndex(1, 2);
    Console.WriteLine("第一页数据:");
    pageOne.ForEach(d=>Console.WriteLine(d.ToString()));
    var pageTwo = GetPageListByIndex(2, 2);
    Console.WriteLine("第二页数据:");
    pageTwo.ForEach(d => Console.WriteLine(d.ToString()));
    var pageThree = GetPageListByIndex(3, 2);
    Console.WriteLine("第三页数据:");
    pageThree.ForEach(d => Console.WriteLine(d.ToString()));
    }

    /// <summary>
    /// 分页
    /// </summary>
    /// <param name="pageIndex">页数</param>
    /// <param name="pageSize">每页行数</param>
    /// <returns></returns>
    static List<Dog> GetPageListByIndex(int pageIndex,int pageSize)
    {
    List<Dog> list = GetDogList().OrderBy(d => d.Id).ToList();
    return list.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
    }

    image

    10.LINQ查询表达式

    image

    image

  • 相关阅读:
    POJ 3268 Silver Cow Party (Dijkstra)
    怒学三算法 POJ 2387 Til the Cows Come Home (Bellman_Ford || Dijkstra || SPFA)
    CF Amr and Music (贪心)
    CF Amr and Pins (数学)
    POJ 3253 Fence Repair (贪心)
    POJ 3069 Saruman's Army(贪心)
    POJ 3617 Best Cow Line (贪心)
    CF Anya and Ghosts (贪心)
    CF Fox And Names (拓扑排序)
    mysql8.0的新特性
  • 原文地址:https://www.cnblogs.com/tangge/p/3396786.html
Copyright © 2011-2022 走看看