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 已经不存在了，都被替换成了初始化值的类型。

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

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

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 );
            }); //匿名方法

6.扩展方法

另外写一个类，（扩展方法）

调用TestExtensionMethod

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

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

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

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

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

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

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

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/>"); });

演化过程

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

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

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

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

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

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

10.LINQ查询表达式