MVC入门之.Net语法学习

时间:2020-12-22 03:22:00

本节中主要学习.Net框架性语法。开发者可以使用新语法提高编程的效率以及代码的运行效率;其本质都是“语法糖”,由编译器在编译时转成原始语法。

u  自动属性 Auto-Implemented Properties

u  隐式类型 var

u  对象初始化器 与 集合初始化器 { }

u  匿名类 & 匿名方法

u  扩展方法

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

u  Lambda表达式

u  标准查询运算符 Standard query operator

u  LINQ查询表达式

Mvc框架简介:

浏览器请求 服务器的 某个 控制器类 的 Action方法,方法中可以调用业务层等代码处理业务,并产生数据Model,交给

视图引擎,视图引擎会找到对应视图,并将数据 “填充到“视图上对应的位置,最终产生整个页面的Html代码,返回给浏览器。

关于编译器:

编译器会在编译的时候,按照C#语法检查代码,C#语法规定变量只能调用其声明类型的成员,如果声明是父类,则只能调用对象里的父类成员

MVC入门之.Net语法学习

自动属性

回顾传统属性概念

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

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

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

int id; //字段

public int Id //属性

{

get { return id; }

set { id = value; }

}

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

public int Id { get; set; }

public int Age { get; set; }

public string Name { get; set; }

u  查看源码:

编译后,也生成了对应的属性语法(get和set方法)

但同时,帮我们生成了一个私有变量

总结:

自动属性主要用在对 字段的 读写权限的封装,帮助减少程序员代码,让代码更好看;但实质上在编译时,还是会自动生成一个对应的字段的。

所以,从这个意义上说,自动属性就相当于是微软提供的一个“语法糖”了。

u  思考:

用自动属性程序员写的代码少了,机器做的事情就多了,那我们到底要不要使用它?

如果 是针对 读写权限的封装,就推荐使用,因为它是在编译的时候产生了负担,并不是在运行的时候。(不会影响客户运行程序时的效率!)

但是编译生成的代码也有一个显而易见的缺点,语法太完整,编译后的程序集会比较大。

隐式类型var

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

int age = 11;//传统方式

u  隐式类型:在初始化时,就已经根据 = 右边的 值 确定了 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。

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

对象/集合初始化器

回顾:

List<Dog> InitList()

{

List<Dog> list = new List<Dog>();

for (int i = 0; i < 10; i++)

{

Dog d = new Dog();

d.Id = i;

d.Name = "Ruiky" + i;

d.Age = i * 2;

d.Toy = new DogToy();

d.Toy.ToyId = i;

d.Toy.ToyName = "狗狗玩具" + i;

list.Add(d);

}

return list;

}

对象集合初始化器语法:

用法1

List<Dog> InitList()

{

List<Dog> list = new List<Dog>();

for (int i = 0; i < 10; i++)

{

Dog d = new Dog

{

Id = i,

Name = "Ruiky" + i,

Age = i * 2,

Toy = new DogToy()//使用属性初始化器

{

ToyId = i,

ToyName = "狗狗玩具" + i

}

};

list.Add(d);

}

return list;

}

//用法2

List<Dog> InitList()

{

List<Dog> list = new List<Dog>{

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = { ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = { ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = { ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = { ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = { ToyId=1, ToyName="小球"}}

};

return list;

}

用初始化器,创建数组!

Dog[] dogs = {

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = new DogToy{ ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = new DogToy{ ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = new DogToy{ ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = new DogToy{ ToyId=1, ToyName="小球"}},

new Dog(){ Id=1, Name="Ruiky", Age=1, Toy = new DogToy{ ToyId=1, ToyName="小球"}}

};

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

匿名类

回顾:

u  匿名类语法:

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

var obj = new

{

Id = 1,

Name = "Ruiky",

Age = 2

};

u  查看源码:

1.编译器自动为 这个 【匿名类】 创建了一个无命名空间的类型。

2.在new 关键字处,创建该匿名类对象

3.编译器创建的匿名类结构

u  注意:

1. 当出现“相同”的匿名类的时候,编译器只会创建一个匿名类

2. 编译器如何区分匿名类是否相同?

根据:

属性名,属性值(因为这些属性是根据值来确定类型的),

属性个数,属性的顺序。

匿名方法

回顾:

普通方法定义方式,因为方法的存在是为了 复用 一段代码,所以一般会给方法取个名字,这个方法的引用就可以通过 "方法名"调用。

void Test()

{

Console.WriteLine("哈哈哈~!");

}

匿名方法:

但是有的方法,不需要复用,仅仅是使用一次就够了,所以不需要方法名,这种方法就叫做匿名方法。

匿名方法必须结合 委托使用。(潜在的意思就是:尽管没有方法名了,但方法的指针还是存放在了某个委托对象中)

如,现在为线程指定要执行的方法的时候,就可以使用匿名方法了。

u  注意:

1.在编译后,会为每个匿名方法创建一个 私有的静态方法,然后将此静态方法传给 委托对象使用。

扩展方法

为什么要有扩展方法?就是为了在不修改源码的情况下,为某个类 增加新的方法。

u  语法:

定义静态类,并添加public的静态方法,第一个参数 代表 扩展方法的扩展类。

a)       它必须放在一个非嵌套、非泛型的静态类中(的静态方法);

b)       它至少有一个参数;

c)       第一个参数必须附加 this 关键字;

d)       第一个参数不能有任何其他修饰符(out/ref)

e)       第一个参数不能是指针类型

public static class DogExtention

{

public static string SayHi(this Dog dogObj)

{

return string.Format("哈哈哈哈~~~我叫{0}!", dogObj.Name);

}

}

//-----------------------

//使用扩展方法

Dog d = new Dog() {

Id = 1, Name = "0094", Age = 11,

Toy = new DogToy() { ToyId=1, ToyName="小骨头" }

};

string str = d.SayHi();//调用扩展方法,此时的对象d就作为第一个参数传到了扩展方法中

编译后: string str = DogExtention.SayHi(d);

u  注意:

1.当我们把扩展方法定义到其它程序集中时,一定要注意调用 扩展方法的环境中包含 扩展方法所在的命名空间。

如,在Extention下为String类添加一个扩展方法

然后在页面中使用时,要记得导入命名空间,否则调用不到扩展方法:

2.扩展方法需要使用特性ExtensionAttribute,当前程序中必须包含程序集ComplilerServices,否则报错如下:

注:此程序集默认在FrameWork3.5开始自动包含。

3.因为扩展方法的本质是被编译后替换成静态方法,所以 对象本身 可以为 null,但是在这个扩展方法中,如果访问了第一个参数,则会报“空指针异常”。

u  查看源码:

1.通过源码看到,在执行 string str = d.SayHi();的地方,编译后变成了 这个扩展方法通过静态类的调用方式代码。由此可见,扩展方法并没有被"扩展"到Dog类中,只不过是在编译的时候替换成了静态类里的静态方法而已。d.SayHi()就是一个语法糖!

u  思考:如果 Dog类中本身就包含 SayHi方法,那会怎么样?

但同时包含同名的 实例方法 和 扩展方法时,优先调用实例方法。

泛型委托

u  回顾通过【比较接口】方式:

让 Dog集合 根据Dog的id排序,需要写一个IComparer<Dog>接口的实现类,在类中重写 接口的 Compare方法,来返回 正整数/0/负整数。

接口:

实现类(比较器):

然后将实现类对象传入集合的Sort方法:

u  使用泛型委托 + 匿名方法实现:

List<T>集合类中包含 新的排序方法,根据 泛型委托Comparison<T> 完成比较过程。

public void Sort(Comparison<T> comparison);

看看这个Comparison<T> 泛型委托:

public delegate int Comparison<in T>(T x, T y);

修改调用的方法:

u  常用系统泛型委托:

1.System.Func 代表有返回类型的委托

public delegate TResult  Func<out TResult>();

public delegate TResult  Func<in T, out TResult>(T arg);

......

注:输入泛型参数-in 最多16个,输出泛型参数 -out 只有一个。

2.System.Action 代表无返回类型的委托//list.ForEach

public delegate void Action<in T>(T obj);

public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);

......

注:参数最多16个

3.System.Predicate<T> 代表返回bool类型的委托   //list.Find

public delegate bool Predicate<in T>(T obj);

4.System.Comparison<T> 代表返回int类型的委托  - 用作比较两个参数的大小

public delegate int Comparison<in T>(T x, T y); //list.Sort

关于泛型委托的泛型参数列表 in out

//泛型委托 的 in 泛型参数 代表 可以被作为 参数列表的类型

//           out 泛型参数 代表 可以被作为 返回值的类型

public delegate T2 DgSay<in T,out T2>(T t1);

Lambda表达式

回顾,发现上面的代码,需要传一个 匿名方法 ,写起来特别别扭。

能否有简化的语法呢?有!Lambda表达式。

概念:

Lambda表达式有两种:

语法:

List<Dog> list = InitList();

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

语法进化史:

查看源码:

C#语法:list.FindAll(d => d.Id > 2);

编译成中间代码后,代码太多,简而言之如下:

编译器帮我们 :

1.声明一个 Predicate<Dog>委托变量;

2.创建一个私有的符合委托签名的静态方法;

3.实例化委托变量,并将方法 传入;

4.调用list.FindAll方法,并传入委托变量。