ASP.NET MVC深入浅出系列(持续更新)
一. ASP.NET体系
从事.Net开发以来,最先接触的Web开发框架是Asp.Net WebForm,该框架高度封装,为了隐藏Http的无状态模式,ViewState功不可没,通过的控件的拖拽和绑定,很快就可以搭建出来一个Web项目,其开发速度远胜Java、PHP,当年Web项目并不很重视体验,没有今天响应式,没有各种前端js框架,所以在当年的WebForm,微软是以引以为豪的。
该框架毕竟有时代局限性,随着前端的崛起,随着人们对项目体验的提高,随着项目的体量的增大,WebForm在当下强调松耦合、模块化、组件化的时代,略显落后,故微软于2009年推出第一个开源框架,即MVC框架,俗称ASP.Net MVC1,后面又陆续的推出 MVC2、3、4、5。现在最新的跨平台Web开发框架 Core MVC,它隶属于.Net Core框架,而非 .Net FrameWork下。
下面用一张图表示一下在Core出现之前,.Net在Web开发即ASP.NET中包含的内容。
简单分析一下:WebPages(没用过哎)、WebForms、MVC均为ASP.NET下的Web开发框架,WebAPI负责构建HTTP常规服务,SignalR负责构建实时服务。
MVC和WebAPI简单对比一下:MVC用来构建网站既关心页面又关心数据,WebAPI只关心数据;MVC通过可以通过Action的名字来接受CURD操作,而WebAPI通过HTTP的访问方式(GET、PUT、POST、DELETE)来表达不同的CURD操作。
(WebService、WCF、WebAPI、SignalR在后面会有单独的章节详细介绍)
二. WebForm和MVC对比
1. WebForm
做过WebForm开发的朋友们应该很清楚,WebForm开发形式主要分为三种:
①:服务器端控件,即拖拽控件(aspx)
②:一般处理程序(ashx) + html模板
③:html静态页 + ajax + 一般处理程序(ashx)
请求模型:
WebForm的几个臭名昭著的缺点:封装太强,导致开发不灵活;ViewState的无状态;声明周期模型复杂,对于初学者不易于理解。
2. MVC
我们经常从各种开发工程师(JAVA 、.NET、PHP)口中听到MVC,但不同人说的MVC貌似类似,但又有区别,那么MVC到底是什么呢?(类似的还有MVP和MVVM)
1. 从宏观上来说:MVC是框架分层的一种搭建思想,在最原始的项目中,没有什么框架分层之说,所有的项目代码都在一个层里,这样会导致代码冗杂,耦合性强,项目迭代升级困难,MVC是一种分层思想,将一个项目代码分为几类,分别放到不同的层里,Model层存储一些数据和业务逻辑,View层处理页面问题,Controller层用来接收人机交互指令。MVC分层思想和传统的三层(数据库访问层、业务逻辑层、表现层)还是有区别的。
MVC的核心是分离了View和Model(即页面和数据),Controller负责接收和发送指令,交给Model层处理。
2. 从.Net的角度来说,MVC是微软提供一个Web开发框架,全称ASP.NET MVC,它是传统三层中View层的一种功能细分,一种表现形式而已,与三层没有直接关系。ASP.NET MVC框架中的开发流程围绕:
① Model:存储实体类,实现系统中的业务逻辑。
② View:页面展示(Razor模板),展现给用户。
③ Controller:页面的逻辑处理,用来与用户的交互,处理接受的Http请求。然后从Model中获取相应的数据,转发给View进行页面展示。
补充:通过Controller中的Action,可以充当APP的服务端接口的作用,和WebAPI达到的效果一致,但访问方式是有区别的。
请求模型:
下面列举MVC框架的几个典型的优点:
①:松耦合,M-V-C分工明确,有利于代码的维护。
②:便于Seo优化,能自定义url的生成规则。
③:ASP.NET MVC5是个出色的表现层框架。
④:对单元测试支持友好。
三. ASP.Net MVC 框架
1. 包含的技术
ASP.NET MVC框架,这里以MVC5为例,涉及到的知识有:Model-View-Controller的使用、Area和Global的理解、路由配置、数据传递的方式、AOP思想的体现(4大过滤器),各种Result、Razor语法、HttpContext相关的五大对象、分布视图、特性的补充、Html扩展控件、Bundles压缩js和css的原理、Owin约束、管道模型及MVC的工作原理。
以及最新的Core MVC框架的相关知识。
2. 常见的约定
①:控制器命名通常以Controller结尾。
②:一个控制器对应一个View视图文件夹,常用页面都存放在里面。
四. 系列章节
第二节:各种路由约束(动态路由、静态路由、组合路由、正则约束、命名空间约束、区域内路由)
第三节:Action向View传值的四种方式(ViewData、ViewBag、TempData、Model)
第四节:MVC中AOP思想的体现(四种过滤器)并结合项目案例说明过滤器的实际用法
第五节:从源码的角度理解MVC中各种Result(ActionResult、JsonResult、JavaScriptResult等)---待补充
第八节:layout和partialView、RenderPartial和Partial、 action和RenderAction(未完成)
第十节:数据批注(DataAnnotationModel)和自定义验证(包括Model级别的验证)
第十三节:HttpHander扩展及应用(自定义扩展名、图片防盗链)
第十五节:HttpContext五大核心对象的使用(Request、Response、Application、Server、Session)
第十六节:利用MVC的扩展完成“一个后台,多套前端页面”的解决方案(未完成)
ORM系列之Entity FrameWork详解(持续更新)
一. 谈情怀
从第一次接触开发到现在(2018年),大约有六年时间了,最初阶段连接数据库,使用的是【SQL语句+ADO.NET】,那时候,什么存储过程、什么事务 统统不理解,生硬的将SQL语句传入SQLHelper类中,后来知道还要注意SQL注入,引入参数化的方式,现在回想一下,那个阶段简直Low到爆。
(PS:现在很多场景下还是需要使用ADO.NET,所以没有最好,只有最适合)
凡事都是从零开始的,正是这个阶段积累,才有了后续的发展。一次机会,接触到了微软的EF(ps:如果没有记错的话,当时用的是EF 5.0 的DBFirst模式),彻底颠覆了我的开发观念,不需要写SQL语句(那时还不清楚EF也可以调用SQL语句),Lambda表达式(并不知道Lambda还分Lambda表达式和Lambda语句),兴奋了一阵,然后进入了漫长的EF摸索和填坑阶段了(EF5.0→EF6.2→EF Core)。
如果你觉得EF不灵活,不能调用存储过程或自定义事务?如果你觉得EF在处理海量数据库的时候会很慢?如果你觉得EF满足不了你的开发需求?。。。。。。 那么也许该系列的文章会对你有些帮助。
二. ORM框架
说起DotNet领域的ORM框架,我们想到的有EF、NHibernate、FluentData、Dapper、SQLSugar等等。那么到底什么是ORM呢?
ORM(Object Relational Mapping),中文名字:对象关系映射,它是面向对象思想的进一步的发扬光大,主要实现【程序对象】到【关系型数据库】的映射。在之前使用ADO.NET开发的时候,数据库访问层(即 DAL),要写很多增加、删除、保存的方法,很是麻烦,如果引入ORM框架,它自带CRUD的API(相当于DAL层已经给你写好了),可以自动生成SQL语句,所以作为开发者而言,只需要关注对象即可。
ORM的含义:
① O:Domain Object 领域模型
② R:Relational DataBase 关系型数据库
③ M : Mapping 映射关系
ORM的三大核心原则:
① 简单性:以最简单的模式建模数据。
② 传达性:数据库结构被任何人都能理解的语言文档化。
③ 精确性:基于数据模型创建正确标准化的结构。
EF的核心架构:
① EDM(Entity Data Model):这是微软提供的一个强大的可视化工具,用来生成 O、R、M的
② 两种语法的查询:LINQ to Entities 和 Entity SQL
③ ObjectServices:Linq to Entities 和Entity Client Data Provider 之间起到转换作用
④ Entity Client Data Provider: 将Lambda转换成SQL语句
⑤ ADO.Net Data Provider: 标准的ADO.Net
⑥ DataBase:数据库
三. 从EF的入手,深入理解ORM框架
EF(Entity FrameWork),是微软推出基于ADO.NET的数据库访问技术,它是一套ORM框架, 框架中包括了实例模型、数据模型、关系映射三部分,EF的上下文为DbContext,EF在 【.Net FrameWork】版本中最新的是 6.2.0 版本,最稳定的是6.2版本,在【.Net Core】中推出 EF Core (即所谓的“EF7”,^_^,当然已经不这么叫了)。
EF包括三种模式:DBFirst、CodeFist、ModelFirst 。EF可以调用SQL语句、可以使用Linq查询、可以使用Lambda查询,EF还有很多高级属性,比如延迟加载、缓存属性等等,在该系列文章中都将逐一详细介绍。
EF也有优缺点:
优点:① EF是微软自家的产品,和VS的集成度很高,极大的提高了开发效率。
② EF中ModelFirst模式提供的模型设计器功能很强大,且采用T4模板生成的代码的功能很强大。
③ 支持多数据库开发,简单的改变配置文件,就可以切换数据库。
缺点: 在复杂的查询生成SQL脚本的效率不是很高,浪费了性能。
举例:之前在开发中,一张幼儿表里大约有60个字段左右,一个业务需要根据复杂的条件查询出来一些信息(大约5个字段左右),当时由于按开发人员的失误,写的Lambda表达式直接将所有字段查询出来,导致该业务耗时很长大约25s左右,后来在我的引导下,先去数据库中直接写SQL语句,查询所有字段,发现速度很快;然后将EF中的Lambda查询改为只查询指定的5个字段,发现速度由25s→3s左右,提升非常明显,当然这也很好的说明了EF的局限是在生成SQL的脚本效率上。
四. 系列章节
第一节: 结合EF的本地缓存属性来介绍【EF增删改操作】的几种形式。
第二节: 比较EF的Lambda查询和Linq查询写法的区别。
第三节: EF调用普通SQL语句的两类封装(ExecuteSqlCommand和SqlQuery )
第四节: EF调用存储过程的通用写法和DBFirst模式子类调用的特有写法
第五节: EF高级属性(一) 之 本地缓存、立即加载、延迟加载(不含导航属性)
第六节: EF高级属性(二) 之延迟加载、立即加载、显式加载(含导航属性)。
第七节: EF的三种事务的应用场景和各自注意的问题(SaveChanges、DBContextTransaction、TransactionScope)。
第八节: EF的性能篇(一) 之 EF自有方法的性能测试 :
第九节: EF的性能篇(二) 之 Z.EntityFramework.Extensions程序集解决EF的性能问题 :
第十节: EF的三种追踪实体属性变化方式(DBEntityEntry、ChangeTracker、Local) :
第十一节: EF的三种模式(一) 之 DBFirst模式(SQLServer和MySQL两套方案):
第十二节: EF的三种模式(二) 之 ModelFirst模式(SQLServer为例):
第十三节: EF的三种模式(三) 之 来自数据库的CodeFirst模式 :
第十四节: EF的三种模式(四) 之 原生正宗的 CodeFirst模式的默认约定 :
第十五节: EF的CodeFirst模式通过DataAnnotations修改默认协定 :
第十六节: EF的CodeFirst模式通过Fluent API修改默认协定 :
第十七节: EF的CodeFirst模式的四种初始化策略和通过Migration进行数据的迁移 :
第十八节: EF的CodeFirst模式连接MySQL数据库的解决方案(未完成) :
第十九节: 结合【表达式目录树】来封装EF的BaseDal层的方法 :
第二十节: 深入理解并发机制以及解决方案(锁机制、EF自有机制、队列模式等):
第二十一节:ADO层次上的海量数据处理方案(SqlBulkCopy类插入和更新):
第二十二节: 以SQLServer为例介绍数据库自有的锁机制(共享锁、更新锁、排它锁等)(未完成) :
第二十三节: EF性能篇(三)之开源组件 Z.EntityFrameWork.Plus.EF6解决EF性能问题 :
第十六节:语法总结(3)(C#6.0和C#7.0新语法)
一. C# 6.0 新语法
1. 自动属性初始化可以赋值
1 /// <summary> 2 /// 自动属性初始化 3 /// </summary> 4 public class UserInfor 5 { 6 public string userId { get; set; } = "123456"; 7 8 public string userName { get; set; } = "lmr"; 9 10 } 11 { 12 Console.WriteLine("------------------------- 1. 自动属性初始化可以赋值----------------------------"); 13 UserInfor uInfor = new UserInfor(); 14 Console.WriteLine($"id={uInfor.userId},userName={uInfor.userName}"); 15 }
2. 字符串嵌入值【$配合{}使用】
特别注意:{}中如果有业务计算需要配合()使用
1 { 2 Console.WriteLine("------------------------- 2. 字符串嵌入值【$配合{}使用】----------------------------"); 3 UserInfor uInfor2 = new UserInfor(); 4 Console.WriteLine($"名字为:{uInfor2.userName}"); 5 //代表要输入一个括号{} 6 Console.WriteLine($"名字为:{{{uInfor2.userName}}}"); 7 //{}中如果有业务计算需要配合()使用 8 Console.WriteLine($"{(uInfor2.userName != "lmr" ? "小鲜肉" : "老鲜肉")}"); 9 }
3. 可以在命名空间出使用static声明静态类
1 { 2 Console.WriteLine($"-------------------------3.可以在命名空间出使用static声明静态类-------------------------"); 3 Console.WriteLine($"之前的使用方式: {Math.Pow(4, 2)}"); 4 Console.WriteLine($"导入后可直接使用方法: {Pow(4, 2)}"); 5 }
4. 空值运算符(?)
不需要判断是否为空了.
1 { 2 Console.WriteLine($"-------------------------4. 空值运算符-------------------------"); 3 int? iValue = 10; 4 Console.WriteLine(iValue?.ToString());//不需要判断是否为空 5 string name = null; 6 Console.WriteLine(name?.ToString()); 7 }
5. 对象初始化
可以直接给字典类型通过类似“索引”的形式赋值 (原先是通过Add方法赋值)
1 { 2 Console.WriteLine($"-------------------------5. 字典对象初始化-------------------------"); 3 Dictionary<string, string> dicList = new Dictionary<string, string>() 4 { 5 ["1"] = "ypf1", 6 ["2"] = "ypf2", 7 ["3"] = "ypf3" 8 }; 9 Dictionary<string, string> dicList2 = new Dictionary<string, string>() 10 { 11 { "1","lmr1"}, 12 { "2","lmr2"}, 13 { "3","lmr3"} 14 }; 15 foreach (var item in dicList) 16 { 17 Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString()); 18 } 19 foreach (var item in dicList2) 20 { 21 Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString()); 22 } 23 }
6. 异常过滤器增加when判断条件
只有符合when里的条件,才能进入catch,如果不满足的话,直接代码报错,不能抛异常
1 { 2 Console.WriteLine("-------------------------6. 异常过滤器增加when判断条件-------------------------"); 3 int epCheck = 100; 4 try 5 { 6 int.Parse("ypf"); 7 } 8 catch (Exception e) when (epCheck > 11) 9 { 10 Console.WriteLine(e.Message); 11 } 12 }
7. nameof表达式
把实例转换成同名的字符串
1 { 2 Console.WriteLine("-------------------------7. nameof表达式-------------------------"); 3 UserInfor userInfor = new UserInfor(); 4 Console.WriteLine(nameof(userInfor)); 5 }
8. 在catch和finally语句块里使用await(暂不介绍,不常用)
9. 在属性或方法上使用Lambada表达式
①:方法针对于只有一行的方法
②:属性通过Lambda的形式进行赋值
public class UserInfor { public string userId { get; set; } = "123456"; public string userName { get; set; } = "lmr"; /// <summary> /// Lambda类型的方法 /// </summary> public void LambdaPrint() => Console.WriteLine("我是Lambda类型的方法"); public string userSex => string.Format("男"); } { Console.WriteLine("-------------------------9.在属性或方法上使用Lambada表达式-------------------------"); UserInfor userInfor = new UserInfor(); userInfor.LambdaPrint(); Console.WriteLine($"userSex的值为:{userInfor.userSex}"); }
二. C# 7.0 新语法
1. out参数的改进
在C#7.0之前, out参数使用前必须先声明,然后传入方法中,在C#7.0后可以直接在传入方法的时候进行声明。
1 /// <summary> 2 /// out参数的改进 3 /// </summary> 4 /// <param name="x"></param> 5 /// <param name="y"></param> 6 public void DoNoting(out int x, out int y) 7 { 8 x = 1; 9 y = 2; 10 } 11 { 12 Console.WriteLine("--------------------1-out参数的改进------------------------"); 13 SevenEdition s = new SevenEdition(); 14 s.DoNoting(out int x, out int y); 15 Console.WriteLine(x + y); 16 }
2. 元组(Tuples)
①:需要通过nuget安装这个System.ValueTuple包
②:元组创建的三种方式:语法糖、Create静态方法、构造函数 (默认情况下是通过Item1、Item2 。。。)
③:指定元祖命名:可以通过左边指定,也可以通过右边指定
④:将元祖应用于方法中返回值,即一个方法可以返回多种不同类型的值,不需要封装实体即可以实现。
1 /// <summary> 2 /// 默认元组命名 3 /// </summary> 4 /// <returns></returns> 5 public (int, string, string) TupleWay1() 6 { 7 return (1, "ypf1", "ypf2"); 8 } 9 /// <summary> 10 /// 指定元祖命名 11 /// </summary> 12 /// <returns></returns> 13 public (int m, string n, string k) TupleWay2() 14 { 15 return (1, "ypf1", "ypf2"); 16 } 17 { 18 Console.WriteLine("--------------------2-元组(Tuples)------------------------"); 19 //1. 创建元组的三种形式 20 Console.WriteLine("--------------------1. 创建元组的三种形式------------------------"); 21 var tuple1 = (1, 2); //语法糖 22 var tuple2 = ValueTuple.Create("ypf", "lmr"); //Create静态方法 23 var tuple3 = new ValueTuple<int, string>(12, "ypf12"); //构造函数 24 Console.WriteLine($"tuple1的两个值为:{tuple1.Item1}和{tuple1.Item2}"); 25 Console.WriteLine($"tuple1的两个值为:{tuple2.Item1}和{tuple2.Item2}"); 26 Console.WriteLine($"tuple1的两个值为:{tuple3.Item1}和{tuple3.Item2}"); 27 28 //2. 指定元祖命名 29 Console.WriteLine("--------------------2. 指定元祖命名------------------------"); 30 (int m, string n) tuple4 = (100, "erp"); //左边命名 31 Console.WriteLine($"tuple4的两个值为:{tuple4.m}和{tuple4.n}"); 32 var tuple5 = (one: 250, two: "spz"); //右边命名 33 Console.WriteLine($"tuple5的两个值为:{tuple5.one}和{tuple5.two}"); 34 35 //3. 元祖应用于方法中返回值 36 Console.WriteLine("--------------------3. 元祖应用于方法中返回值------------------------"); 37 SevenEdition s = new SevenEdition(); 38 //默认命名 39 var result1 = s.TupleWay1(); 40 Console.WriteLine($"返回值有:{result1.Item1}、{result1.Item2}、{result1.Item3}"); 41 //指定命名 42 var result2 = s.TupleWay2(); 43 Console.WriteLine($"返回值有:{result2.m}、{result2.n}、{result2.k}"); 44 45 }
3. 局部函数
即在{}中声明一个函数,只有{}中能使用
1 { 2 Console.WriteLine("--------------------3-局部函数------------------------"); 3 DoSome(); 4 void DoSome() 5 { 6 Console.WriteLine("我是局部函数"); 7 } 8 }
4. 模式的比较和匹配
①:is的新模式。
首先补充一个概念:拆箱和装箱
拆箱是将引用类型→值类型 (object ,class均为引用类型)
装箱是将值类型→引用类型
案例:有一个object类型的变量a,如果它是int类型,则+10赋值给m,并输出m的值,下面看新老用法比较。
1 { 2 Console.WriteLine("--------------------4-模式比较(is)------------------------"); 3 object a = 9; 4 //老写法 5 if (a is int) 6 { 7 int b = (int)a; //拆箱 8 int c = b + 10; 9 Console.WriteLine($"老写法c的值为:{c}"); 10 } 11 //新写法 12 if (a is int m) //这里的a直接拆箱为m 13 { 14 int c = m + 10; 15 Console.WriteLine($"新写法c的值为:{c}"); 16 } 17 }
②:switch-case中可以自定义参数类型
传统情况,所有的case中必须是同类型的;而在C# 7.0 新版本中,case中可以不同类型,即Swich中可以传入任何类型,然后通过case中进行对应匹配,这就叫做模式匹配。
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 /// <summary> 2 /// 单一类型 3 /// </summary> 4 /// <param name="m"></param> 5 /// <returns></returns> 6 public dynamic SwitchWay1(string m) 7 { 8 dynamic data; 9 switch (m) 10 { 11 case "ypf1": 12 data = m + "lmr1"; 13 break; 14 case "ypf2": 15 data = m + "lmr2"; 16 break; 17 default: 18 data = "spz00000"; 19 break; 20 } 21 return data; 22 } 23 24 /// <summary> 25 /// 多种类型 26 /// </summary> 27 /// <param name="m"></param> 28 /// <returns></returns> 29 public dynamic SwitchWay2(object m) 30 { 31 dynamic data; 32 switch (m) 33 { 34 case int a when a > 10: 35 data = a + 10; 36 break; 37 case int b: 38 data = b + 100; 39 break; 40 case String c: 41 data = c + "mmmmmmmmmmmmmmm"; 42 break; 43 default: 44 data = "spz00000"; 45 break; 46 } 47 return data; 48 }
1 { 2 Console.WriteLine("--------------------4-模式匹配(switch-case)------------------------"); 3 SevenEdition sE = new SevenEdition(); 4 //老用法 5 var data1 = sE.SwitchWay1("ypf1"); 6 Console.WriteLine($"类型为:{data1.GetType()},值为:{data1}"); 7 //新用法 8 var data2 = sE.SwitchWay2(1); 9 Console.WriteLine($"类型为:{data2.GetType()},值为:{data2}"); 10 11 var data3 = sE.SwitchWay2(11); 12 Console.WriteLine($"类型为:{data3.GetType()},值为:{data3}"); 13 14 var data4 = sE.SwitchWay2("ypf1"); 15 Console.WriteLine($"类型为:{data4.GetType()},值为:{data4}"); 16 17 }
5. 数字文本语法的改写
比如10000000 可以写成10_000_000 ,方便识别。
{ Console.WriteLine("--------------------5-数字文本语法的改写------------------------"); long a = 10000000; long b = 10_000_000; Console.WriteLine($"a的值为:{a},b的值为:{b}"); }
6. 补充一些特殊地方也可以写异常表达式 (不详细测试了)
比如:条件表达式(? :)、null合并运算符(??)、一些Lambda
eg:private string _name = GetName() ?? throw new ArgumentNullException(nameof(GetName));
第三节:深度剖析各类数据结构(Array、List、Queue、Stack)及线程安全问题和yeild关键字
一. 各类数据结构比较及其线程安全问题
1. Array(数组):
分配在连续内存中,不能随意扩展,数组中数值类型必须是一致的。数组的声明有两种形式:直接定义长度,然后赋值;直接赋值。
缺点:插入数据慢。
优点:性能高,数据再多性能也没有影响
特别注意:Array不是线程安全,在多线程中需要配合锁机制来进行,如果不想使用锁,可以用ConcurrentStack这个线程安全的数组来替代Array。
1 { 2 Console.WriteLine("---------------------------01 Array(数组)-----------------------------------"); 3 //模式一:声明数组并指定长度 4 int[] array = new int[3]; 5 //数组的赋值通过下标来赋值 6 for (int i = 0; i < array.Length; i++) 7 { 8 array[i] = i + 10; 9 } 10 //数组的修改通过下标来修改 11 array[2] = 100; 12 //输出 13 for (int j = 0; j < array.Length; j++) 14 { 15 Console.WriteLine(array[j]); 16 } 17 18 //模式二:直接赋值 19 string[] array2 = new string[] { "二胖", "二狗" }; 20 }
2. ArrayList(可变长度的数组)
不必在声明的时候指定长度,即长度可变;可以存放不同的类型的元素。
致命缺点:无论什么类型存到ArrayList中都变为object类型,使用的时候又被还原成原先的类型,所以它是类型不安全的,当值类型存入的时候,会发生装箱操作,变为object引用类型,而使用的时候,又将object类型拆箱,变为原先的值类型,这尼玛,你能忍?
结论:不推荐使用,建议使用List代替!!
特别注意:ArrayList不是线程安全,在多线程中需要配合锁机制来进行。
1 { 2 Console.WriteLine("---------------------------02 ArrayList(可变长度的数组)-----------------------------------"); 3 ArrayList arrayList = new ArrayList(); 4 arrayList.Add("二胖"); 5 arrayList.Add("马茹"); 6 arrayList.Add(100); 7 for (int i = 0; i < arrayList.Count; i++) 8 { 9 Console.WriteLine(arrayList[i] + "类型为:" + arrayList[i].GetType()); 10 } 11 }
3. List<T> (泛型集合) 推荐使用
内部采用array实现,但没有拆箱和装箱的风险,是类型安全的
特别注意:List<T>不是线程安全,在多线程中需要配合锁机制来进行,如果不想使用锁,可以用ConcurrentBag这个线程安全的数组来替代List<T>
1 { 2 Console.WriteLine("---------------------------03 List<T> (泛型集合)-----------------------------------"); 3 List<string> arrayList = new List<string>(); 4 arrayList.Add("二胖"); 5 arrayList.Add("马茹"); 6 arrayList.Add("大胖"); 7 //修改操作 8 arrayList[2] = "葛帅"; 9 //删除操作 10 //arrayList.RemoveAt(0); 11 for (int i = 0; i < arrayList.Count; i++) 12 { 13 Console.WriteLine(arrayList[i]); 14 } 15 }
4. LinkedList<T> 链表
在内存空间中存储的不一定是连续的,所以和数组最大的区别就是,无法用下标访问。
优点:增加删除快,适用于经常增减节点的情况。
缺点:无法用下标访问,查询慢,需要从头挨个找。
特别注意:LinkedList<T>不是线程安全,在多线程中需要配合锁机制来进行。
{ Console.WriteLine("---------------------------04 ListLink<T> 链表-----------------------------------"); LinkedList<string> linkedList = new LinkedList<string>(); linkedList.AddFirst("二胖"); linkedList.AddLast("马茹"); var node1 = linkedList.Find("二胖"); linkedList.AddAfter(node1, "三胖"); //删除操作 linkedList.Remove(node1); //查询操作 foreach (var item in linkedList) { Console.WriteLine(item); } }
5. Queue<T> 队列
先进先出,入队(Enqueue)和出队(Dequeue)两个操作
特别注意:Queue<T>不是线程安全,在多线程中需要配合锁机制来进行,如果不想使用锁,线程安全的队列为 ConcurrentQueue。
实际应用场景:利用队列解决高并发问题(详见:http://www.cnblogs.com/yaopengfei/p/8322016.html)
1 { 2 Console.WriteLine("---------------------------05 Queue<T> 队列-----------------------------------"); 3 Queue<int> quereList = new Queue<int>(); 4 //入队操作 5 for (int i = 0; i < 10; i++) 6 { 7 quereList.Enqueue(i + 100); 8 } 9 //出队操作 10 while (quereList.Count != 0) 11 { 12 Console.WriteLine(quereList.Dequeue()); 13 } 14 }
6. Stack<T> 栈
后进先出,入栈(push)和出栈(pop)两个操作
特别注意:Stack<T>不是线程安全
1 { 2 Console.WriteLine("---------------------------06 Stack<T> 栈-----------------------------------"); 3 Stack<int> stackList = new Stack<int>(); 4 //入栈操作 5 for (int i = 0; i < 10; i++) 6 { 7 stackList.Push(i + 100); 8 } 9 //出栈操作 10 while (stackList.Count != 0) 11 { 12 Console.WriteLine(stackList.Pop()); 13 } 14 }
7. Hashtable
典型的空间换时间,存储数据不能太多,但增删改查速度非常快。
特别注意:Hashtable是线程安全的,不需要配合锁使用。
{ Console.WriteLine("---------------------------07 Hashtable-----------------------------------"); Hashtable tableList = new Hashtable(); //存储 tableList.Add("001", "马茹"); tableList["002"] = "二胖"; //查询 foreach (DictionaryEntry item in tableList) { Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString()); } }
8. Dictionary<K,T>字典 (泛型的Hashtable)
增删改查速度非常快,可以用来代替实体只有id和另一个属性的时候,大幅度提升效率。
特别注意:Dictionary<K,T>不是线程安全,在多线程中需要配合锁机制来进行,如果不想使用锁,线程安全的字典为 ConcurrentDictionary。
1 { 2 Console.WriteLine("---------------------------08 Dictionary<K,T>字典-----------------------------------"); 3 Dictionary<string, string> tableList = new Dictionary<string, string>(); 4 //存储 5 tableList.Add("001", "马茹"); 6 tableList.Add("002", "二胖"); 7 tableList["002"] = "三胖"; 8 //查询 9 foreach (var item in tableList) 10 { 11 Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString()); 12 } 13 }
强调:
以上8种类型,除了Hashtable是线程安全,其余都不是,都需要配合lock锁来进行,或者采用 ConcurrentXXX来替代。
详细的请见:http://www.cnblogs.com/yaopengfei/p/8322016.html
二. 四大接口比较
1. IEnumerable
是最基本的一个接口,用于迭代使用,里面有GetEnumerator方法。
2. ICollection
继承了IEnumerable接口,主要用于集合,内部有Count属性表示个数,像ArrayList、List、LinkedList均实现了该接口。
3. IList
继承了IEnumerable 和 ICollection,实现IList接口的数据接口可以使用索引访问,表示在内存上是连续分配的,比如Array、List。
4. IQueryable
这里主要和IEnumerable接口进行对比。
Enumerable里实现方法的参数是Func委托,Queryable里实现的方法的参数是Expression表达式。
实现IQueryable和IEnumabler均为延迟加载,但二者的实现方式不同,前者为迭代器模式,参数为Func委托,后者为Expression表达式目录树实现。
三. yield关键字
1. yield必须出现在IEunmerable中
2. yield是迭代器的状态机,能做到延迟查询,使用的时候才查询,可以实现按序加载
3. 例子
测试一:在 “var data1 = y.yieldWay();”加一个断点,发现直接跳过,不能进入yieldWay方法中,而在“foreach (var item in data1)”加一个断点,第一次遍历的时候就进入了yieldWay方法中,说明了yield是延迟加载的,只有使用的时候才查询。
测试二:对yieldWay和commonWay获取的数据进行遍历,通过控制台发现前者是一个一个输出,而后者是先一次性获取完,一下全部输出来,证明了yield可以做到按需加载,可以在foreach中加一个限制,比如该数据不满足>100就不输出。
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 //********************************* 下面为对比普通返回值和使用yeild返回值的方法 ************************************************ 2 3 /// <summary> 4 /// 含yield返回值的方法 5 /// </summary> 6 /// <returns></returns> 7 public IEnumerable<int> yieldWay() 8 { 9 for (int i = 0; i < 10; i++) 10 { 11 yield return this.Get(i); 12 } 13 } 14 /// <summary> 15 /// 普通方法 16 /// </summary> 17 /// <returns></returns> 18 public IEnumerable<int> commonWay() 19 { 20 int[] intArray = new int[10]; 21 for (int i = 0; i < 10; i++) 22 { 23 intArray[i] = this.Get(i); 24 } 25 return intArray; 26 } 27 28 /// <summary> 29 /// 一个获取数据的方法 30 /// </summary> 31 /// <param name="num"></param> 32 /// <returns></returns> 33 private int Get(int num) 34 { 35 Thread.Sleep(1000); 36 return num * DateTime.Now.Second; 37 }
1 Console.WriteLine("-----------------------下面是调用yield方法-----------------------"); 2 yieldDemo y = new yieldDemo(); 3 var data1 = y.yieldWay(); 4 foreach (var item in data1) 5 { 6 Console.WriteLine(item); 7 } 8 Console.WriteLine("-----------------------下面是调用普通方法-----------------------"); 9 var data2 = y.commonWay(); 10 foreach (var item in data2) 11 { 12 Console.WriteLine(item); 13 }
各种通讯连接方式
1. http https (ajax)
2. 总结一下同一个项目下 前后交互的集中提交方式 (.Net特有的 EasyUI封装的)
3. 跨域请求的几种形式
3. HttpClient
4. WebService
5. WebAPI(重点)
6. socket
7. websocket (重点)+superSocket
8. SignalR (重点)
9. nodejs中的net通讯模块
10. WCF (可以弃疗了)
设计模式篇
一. 什么是设计模式
纠结了好久,今天终于下定决心开始写设计模式系列,因为这个系列章节确实不好写,在这之前,也看了好多关于设计模式的博客、视频、书籍等,大多数用的例子要么猫啊狗啊、大雁等动物类;要么就是学生类,教师类,吐槽一下,真shit,试想一下,哪个项目中会用这些动物类教师类呢?
我也和我同行的朋友交流了一下关于设计模式,对设计模式的理解,可以分为这么几个层次:
①:根本不知道什么是设计模式。
②:听说过几种设计模式,理解不深。
③:能写出并理解几种设计模式,但不知道在项目中该怎么用。
毋庸置疑,能否灵活的运用好设计模式,是一个名开发工程师迈向架构师的必经之路,上面说的这么玄乎,那么到底什么是涉及模式呢?这里先借助金庸的武侠小说来类比一下。
作为金庸迷的我,金庸老师的“飞雪连天射白鹿,笑书神侠倚碧鸳”14部小说每一部看了都不低于3遍以上,对里面个各种武功也是了如指掌,像效果比较炫丽,威力比较大的有:“乔帮主降龙十八掌、段誉的六脉神剑、杨过的黯然销魂掌、任我行的吸星大法等等”,这些都是外家功夫,种类很多,一个人可能会多种,这就好比.Net的中MVC、EF、SignalR等等;当然也有内功心法,典型的有:”少林和尚的易筋经、张无忌的九阳神功”,这两种功夫本身并没有太大的杀伤力,但会了这种功夫,更容易融会贯通外家功夫,使外家功夫发挥出更大效果,拿到我们开发领域,“设计模式”就是内功心法,没有语言之分,它是一种模式,一种思想指导着我们开发。
那么怎么才能算精通设计模式呢?
看过《倚天屠龙记》的朋友可能会记得里面有这么一个场景:赵敏冒充明教挑战张三丰的时候,张无忌办成小道童出来救场,在对阵三个家奴的的时候,张三丰教了张无忌一套太极拳法,里面有这么一段对话:
张三丰演示完后,问张无忌:“无忌,你记住了多少”,张无忌回答说:“无忌不才,只有一小部分没有记住”;过了一会,张三丰又问道:“现在能记住多少”,无忌说:“太师傅,我已经全部忘记了”,这时,张三丰说:“无忌你可以上了”,结果显然而知,对手被打的那叫一个惨啊。
所以:设计模式的最高境界是,忘记设计模式,将23种的设计模式自然而然的融入开发中,哈哈,当然这个有点难,没有个五年以上的功力,很难达到这个层次。
二. 设计模式的内容
设计模式是一种套路,是把 “别人成功的例子” 拿过来灵活运用,我们的优秀的前辈总结出来7个设计原则和23种设计模式。
设计原则:
1. 单一职责原则 2. 里氏替换原则 3. 依赖倒置原则
4. 接口隔离原则 5. 迪米特原则(最小知道原则) 6. 开闭原则
7. 组合聚合原则
设计模式:
1. 创建型模式 :工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
2. 结构型模式:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
3. 行为型模式:策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
解释:设计模式只是一个大概的套路,不能生搬硬套,有一些做法可能是多个设计模式的融合,有的也很难归为某个设计模式。不要为了设计模式而设计模式,没有十全十美的代码。
在上述设计模式中,大部分设计模式都用到了上面的设计思想,在设计模式中,我们会经常看到:开闭原则、里氏替换原则(多态)、面向接口编程、面向抽象编程、抽象类、override覆写这几种技术。
如果对于抽象类或者override不明白的,有必要先看一下下面的章节:
第一节:从面向对象思想(oo)开发、接口、抽象类以及二者比较
第二节:重写(new)、覆写(overwrite)、和重载(overload)
三. 系列章节
下面将由浅入深,结合实际案例来讲解设计原则和设计模式。
第二节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第三节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第四节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第五节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第六节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第七节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第八节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第九节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十一节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十二节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十三节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十四节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十五节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十六节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十七节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十八节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第十九节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十一节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十二节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十三节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十四节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十五节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十六节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十七节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十八节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第二十九节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第三十节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第三十一节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第三十二节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
第三十三节:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
(进度:一周写 2-3篇,大约2个半月 完成该系列)
第十二节: 总结Quartz.Net几种部署模式(IIS、Exe、服务部署【借助TopSelf、服务类】)
一. IIS部署
比如在MVC框架中集成了Quartz.Net定时调度,此时该调度系统会随着MVC框架被挂在IIS下,IIS会进程回收,所以大部分开发都会遇到Quartz挂在IIS下一段时间不好用。
补充:IIS可以设置定时自动回收,默认回收是1740分钟,也就是29小时。IIS自动回收相当于服务器IIS重启,应用程序池内存清空,所有数据被清除,相当于IIS重启,在度量快速开发平台服务器端,为了减小数据库负担,内存中暂存了很多信息,不适合频繁的回收,因为回收会造成服务器端所有存在内存中的数据丢失,如果没有及时保存到数据库中,可能导致程序出现问题。而如果系统使用高峰时期,并不适合回收,回收可能导致几十秒IIS无响应,对于正在工作的人员来说,是一种很不好的体验,会以为是网络或者掉线等问题。
解决方案:关闭该项目在IIS上对应的进程池的回收机制。
如何关闭进程池的回收机制:选中IIS中部署的项目对应的进程池,点击【高级设置】,里面有5个核心参数:
① 发生配置更改时禁止回收:如果为True,应用程序池在发生配置更改时将不会回收。
② 固定时间间隔(分钟):超过设置的时间后,应用程序池回收,设置为:0 意味着应用程序池不回收。系统默认设置的时间是1740(29小时)。
③ 禁用重叠回收:如果为true,将发生应用程序池回收,以便在创建另一个工作进程之前退出现有工作进程
④ 请求限制:应用程序池在回收之前可以处理的最大请求数。如果值为0,则表示应用程序池可以处理的请求数没有限制。
⑤ 生成回收事件日志条目:每发生一次指定的回收事件时便产生一个事件日志条目。
总结:即使可以将IIS进程池回收关掉,仍然不建议把Quartz挂到IIS下,长时间不回收,会存在内存溢出的问题。
二. C/S程序直接运行
我们可以用控制台的形式或者Winform的形式单独做一套定时调度系统,与主框架分类,也便于维护,可以直接将exe程序或者Winform窗体程序在服务器上运行。
总结:该方法不存在回收的问题,但直接在服务器上运行,容易不小心被运维人员关掉了。
对于专业一点的人员来说,该方案,直接运行程序太Low了,所以通常是将exe程序发不成windows服务,通过服务的开启和关闭来 维护。
三. 借助topshelf来进行的windows服务部署
官网:http://topshelf-project.com/ , 这是一种通用的发布服务的方式,步骤如下:
1. 通过NuGet下载 Topshelf 的程序集
2. 配置QuartzService类,充当定时任务的服务端程序
①:构造函数中执行定时调度任务
②:Start()方法控制调度的开启 (必填)
③:Stop()方法控制调度的关闭 (必填)
④:Pause()方法暂停调度 (选填)
⑤:Continue()方法继续调度 (选填)
⑥:Shutdown() 关闭 (需要支持)
3. 在主程序中通过topshelf代码调用: HostFactory.Run 详见主程序。(在里面可以设置服务的名称、描述等)
4. 通过指令进行服务发布和卸载(查看windows服务:services.msc)
①:通过cmd命令定位到bin文件目录下(以管理员身份运行)
(eg: 先输入 d: 切换到D盘,再执行下面的命令 cd D:\06-我的开发之路\DotNet体系\04-DotNet专题篇\01-Quartz.Net定时调度\01-Code\MyQuarzt\QuartzDemo\bin\Debug )
②:QuartzDemo.exe help: 查看指令
QuartzDemo.exe install: 安装服务
QuartzDemo.exe install start : 安装服务且开启
QuartzDemo.exe uninstall :卸载服务
截止此处,大功告成,可以看到D盘中多了一个txt文件,每隔3s多一条数据
下面分享整个过程的代码部署的相应截图:
(1). Quartz代码和TopSelf调用代码:
1 public class QuartzService 2 { 3 IScheduler scheduler = null; 4 /// <summary> 5 /// 定时调度业务 6 /// </summary> 7 public QuartzService() 8 { 9 //1.创建作业调度池(Scheduler) 10 scheduler = StdSchedulerFactory.GetDefaultScheduler(); 11 12 //2.创建一个具体的作业即job (具体的job需要单独在一个文件中执行) 13 var job = JobBuilder.Create<HelloJob5>().Build(); 14 15 //3.创建并配置一个触发器即trigger 3s执行一次 16 var trigger = TriggerBuilder.Create().WithSimpleSchedule(x => x.WithIntervalInSeconds(3) 17 .RepeatForever()).Build(); 18 //4.将job和trigger加入到作业调度池中 19 scheduler.ScheduleJob(job, trigger); 20 } 21 /// <summary> 22 /// 开启任务 23 /// </summary> 24 public void Start() 25 { 26 scheduler.Start(); 27 } 28 /// <summary> 29 /// 关闭任务 30 /// </summary> 31 public void Stop() 32 { 33 //true:表示该Sheduler关闭之前需要等现在所有正在运行的工作完成才能关闭 34 //false:表示直接关闭 35 scheduler.Shutdown(true); 36 } 37 /// <summary> 38 /// 暂停调度 39 /// </summary> 40 public void Pause() 41 { 42 scheduler.PauseAll(); 43 } 44 /// <summary> 45 /// 继续调度 46 /// </summary> 47 public void Continue() 48 { 49 scheduler.ResumeAll(); 50 } 51 52 }
1 HostFactory.Run(x => //1 2 { 3 x.Service<QuartzService>(s => //2 4 { 5 s.ConstructUsing(name => new QuartzService()); //3 6 //开启和关闭 必选项 7 s.WhenStarted(tc => tc.Start()); //4 8 s.WhenStopped(tc => tc.Stop()); //5 9 10 // optional pause/continue methods if used 11 // 暂停和继续 选填 12 s.WhenPaused(tc => tc.Pause()); 13 s.WhenContinued(tc => tc.Continue()); 14 15 optional, when shutdown is supported 16 //s.WhenShutdown(tc => tc.Shutdown()); 17 18 }); 19 x.RunAsLocalSystem(); //6 20 x.SetDescription("测试借助TopSelf将Quartz发布成服务"); //7 21 x.SetDisplayName("QuartzService"); //8 22 x.SetServiceName("QuartzService2"); //9 23 });
(2). 定位到指定路径,并进行相应的服务部署
a. 很多指令
b. 安装服务并开启
查看服务列表:
查看服务运行结果:
删除服务:
三. 借助window服务类
这里不详细介绍(网上一堆一堆的),推荐采用上面的TopShelf的服务发布方式。