第十五节：深入理解async和await的作用及各种适用场景和用法

一. 同步VS异步

1.   同步 VS 异步 VS 多线程

同步方法：调用时需要等待返回结果，才可以继续往下执行业务

异步方法：调用时无须等待返回结果，可以继续往下执行业务

开启新线程：在主线程之外开启一个新的线程去执行业务

同步方法和异步方法的本质区别： 调用时是否需要等待返回结果才能继续执行业务

2. 常见的异步方法（都以Async结尾）

　　① HttpClient类：PostAsync、PutAsync、GetAsync、DeleteAsync

　　② EF中DbContext类：SaveChangesAsync

　　③ 文件相关中的：WriteLineAsync

3. 引入异步方法的背景

　　比如我在后台要向另一台服务器中获取中的2个接口获取信息，然后将两个接口的信息拼接起来，一起输出，接口1耗时3s，接口2耗时5s，

① 传统的同步方式：

　　需要的时间大约为：3s + 5s =8s, 如下面 【案例1】

先分享一个同步请求接口的封装方法，下同。

 View Code

然后在分享服务上的耗时操作，下同。

 View Code

下面是案例1代码

复制代码

 1  　　　　　　#region 案例1(传统同步方式 耗时8s左右)2             {3                 Stopwatch watch = Stopwatch.StartNew();4                 Console.WriteLine("开始执行");5 6                 string t1 = HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");7                 string t2 = HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");8 9                 Console.WriteLine("我是主业务");
10                 Console.WriteLine($"{t1},{t2}");
11                 watch.Stop();
12                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
13             }
14             #endregion

复制代码

② 开启新线程分别执行两个耗时操作

　　需要的时间大约为：Max(3s,5s) = 5s ,如下面【案例2】

复制代码

 1   　　　　　　#region 案例2(开启新线程分别执行两个耗时操作 耗时5s左右)2             {3                 Stopwatch watch = Stopwatch.StartNew();4                 Console.WriteLine("开始执行");5 6                 var task1 = Task.Run(() =>7                 {8                     return HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");9                 });
10 
11                 var task2 = Task.Run(() =>
12                 {
13                     return HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
14                 });
15 
16                 Console.WriteLine("我是主业务");
17                 //主线程进行等待
18                 Task.WaitAll(task1, task2);
19                 Console.WriteLine($"{task1.Result},{task2.Result}");
20                 watch.Stop();
21                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
22             }
23             #endregion

复制代码

　　既然②方式可以解决同步方法串行耗时间的问题，但这种方式存在一个弊端，一个业务中存在多个线程，且需要对线程进行管理，相对麻烦，从而引出了异步方法。

这里的异步方法 我 特指：系统类库自带的以async结尾的异步方法。

③ 使用系统类库自带的异步方法

　　需要的时间大约为：Max(3s,5s) = 5s ,如下面【案例3】

复制代码

 1 　　　　　　#region 案例3(使用系统类库自带的异步方法 耗时5s左右)2             {3                 Stopwatch watch = Stopwatch.StartNew();4                 HttpClient http = new HttpClient();5                 var httpContent = new StringContent("", Encoding.UTF8, "application/json");6                 Console.WriteLine("开始执行");7                 //执行业务8                 var r1 = http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);9                 var r2 = http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
10                 Console.WriteLine("我是主业务");
11 
12                 //通过异步方法的结果.Result可以是异步方法执行完的结果
13                 Console.WriteLine(r1.Result.Content.ReadAsStringAsync().Result);
14                 Console.WriteLine(r2.Result.Content.ReadAsStringAsync().Result);
15 
16                 watch.Stop();
17                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
18             }
19             #endregion

复制代码

PS：通过 .Result 来获取异步方法执行完后的结果。

二. 利用async和await封装异步方法

1. 首先要声明几点：

　　① async和await关键字是C# 5.0时代引入的，它是一种异步编程模型

　　② 它们本身并不创建新线程，但我可以在自行封装的async中利用Task.Run开启新线程

　　③ 利用async关键字封装的方法中如果写全部都是一些串行业务, 且不用await关键字，那么即使使用async封装，也并没有什么卵用，并起不了异步方法的作用。

　　 需要的时间大约为：3s + 5s =8s, 如下面 【案例4】，并且封装的方法编译器会提示：“缺少关键字await，将以同步的方式调用，请使用await运算符等待非阻止API或Task.Run的形式”（PS：非阻止API指系统类库自带的以Async结尾的异步方法）

复制代码

 1        //利用async封装同步业务的方法2         private static async Task<string> NewMethod5Async()3         {4             Thread.Sleep(3000);5             //其它同步业务6             return "Msg1";7         }8         private static async Task<string> NewMethod6Async()9         {
10             Thread.Sleep(5000);
11             //其它同步业务
12             return "Msg2";
13         }

复制代码

复制代码

 1            #region 案例4(async关键字封装的方法中如果写全部都是一些串行业务 耗时8s左右)2             {3                 Stopwatch watch = Stopwatch.StartNew();4 5                 Console.WriteLine("开始执行");6 7                 Task<string> t1 = NewMethod5Async();8                 Task<string> t2 = NewMethod6Async();9 
10                 Console.WriteLine("我是主业务");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

复制代码

　　观点结论1：从上面③中可以得出一个结论，async中必须要有await运算符才能起到异步方法的作用，且await 运算符只能加在 系统类库默认提供的异步方法或者新线程（如：Task.Run）前面。

　　 如：下面【案例5】 和 【案例6】需要的时间大约为：Max(3s,5s) = 5s

复制代码

 1 // 将系统类库提供的异步方法利用async封装起来2         private static async Task<String> NewMethod1Async()3         {4             HttpClient http = new HttpClient();5             var httpContent = new StringContent("", Encoding.UTF8, "application/json");6             //执行业务7             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);8             return r1.Content.ReadAsStringAsync().Result;9         }
10         private static async Task<String> NewMethod2Async()
11         {
12             HttpClient http = new HttpClient();
13             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
14             //执行业务
15             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
16             return r1.Content.ReadAsStringAsync().Result;
17         }
18 
19         //将await关键字加在新线程的前面
20         private static async Task<string> NewMethod3Async()
21         {
22             var msg = await Task.Run(() =>
23             {
24                 return HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
25             });
26             return msg;
27         }
28         private static async Task<string> NewMethod4Async()
29         {
30             var msg = await Task.Run(() =>
31             {
32                 return HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
33             });
34             return msg;
35         }

复制代码

复制代码

 1  　　　　　　#region 案例5(将系统类库提供的异步方法利用async封装起来 耗时5s左右)2             //并且先输出“我是主业务”，证明t1和t2是并行执行的，且不阻碍主业务3             {4                 Stopwatch watch = Stopwatch.StartNew();5 6                 Console.WriteLine("开始执行");7                 Task<string> t1 = NewMethod1Async();8                 Task<string> t2 = NewMethod2Async();9 
10                 Console.WriteLine("我是主业务");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

复制代码

复制代码

 1    　　　　#region 案例6(将新线程利用async封装起来 耗时5s左右)2             //并且先输出“我是主业务”，证明t1和t2是并行执行的，且不阻碍主业务3             {4                 Stopwatch watch = Stopwatch.StartNew();5 6                 Console.WriteLine("开始执行");7                 Task<string> t1 = NewMethod3Async();8                 Task<string> t2 = NewMethod4Async();9 
10                 Console.WriteLine("我是主业务");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

复制代码

2. 几个规则和约定

　　① async封装的方法中，可以有多个await，这里的await代表等待该行代码执行完毕。

　　② 我们通常自己封装的方法也要以Async结尾，方便识别

　　③ 异步返回类型主要有三种：Task<T> 、Task、Void

3. 测试得出其他几个结论

① 如果async封装的异步方法里既有同步业务又有异步业务(开启新线程或者系统类库提供异步方法)，那么同步方法那部分的时间在调用的时候是会阻塞主线程的，即主线程要等待这部分同步业务执行完才能往下执行。

　　如【案例7】 耗时：同步操作之和 2s+2s + Max(3s,5s)=9s;

 View Code

复制代码

 1  　　　　 #region 案例7(既有普通的耗时操作，也有系统本身的异步方法,耗时9s左右)2             //且大约4s后才能输出 “我是主业务”，证明同步操作Thread.Sleep(2000);  阻塞主线程3             {4                 Stopwatch watch = Stopwatch.StartNew();5 6                 Console.WriteLine("开始执行");7                 Task<string> t1 = NewMethod7Async();8                 Task<string> t2 = NewMethod8Async();9 
10                 Console.WriteLine("我是主业务");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

复制代码

　　

　　证明：async封装的异步方法里的同步业务的时间会阻塞主线程，再次证明 await只能加在 非阻止api和开启新线程的前面

② 如果封装的异步方法中存在等待的问题，而且不能阻塞主线程(不能用Thread.Sleep) , 这个时候可以用Task.Delay，并在前面加await关键字

　　如【案例8】 耗时：Max（2+3 , 5+2）=7s

复制代码

 1    //利用Task.Delay(2000);等待2         private static async Task<String> NewMethod11Async()3         {4             //调用异步方法之前需要等待2s5             await Task.Delay(2000);6 7             //下面的操作耗时3s8             HttpClient http = new HttpClient();9             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
10             //执行业务
11             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
12             return r1.Content.ReadAsStringAsync().Result;
13         }
14 
15         private static async Task<String> NewMethod12Async()
16         {
17             //调用异步方法之前需要等待2s
18             await Task.Delay(2000);
19 
20             //下面的操作耗时5s
21             HttpClient http = new HttpClient();
22             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
23             //执行业务
24             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
25             return r1.Content.ReadAsStringAsync().Result;
26         }

复制代码

复制代码

 1  　　　　　　 #region 案例8(利用Task.Delay执行异步方法的等待操作)2             //结果是7s，且马上输出“我是主业务”，说明Task.Delay(),不阻塞主线程。3             {4                 Stopwatch watch = Stopwatch.StartNew();5                 Console.WriteLine("开始执行");6                 Task<string> t1 = NewMethod11Async();7                 Task<string> t2 = NewMethod12Async();8 9                 Console.WriteLine("我是主业务");
10                 Console.WriteLine($"{t1.Result},{t2.Result}");
11                 watch.Stop();
12                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
13             }
14             #endregion

复制代码

三. 异步方法返回类型

1. Task<T>, 处理含有返回值的异步方法，通过 .Result 等待异步方法执行完，且获取到返回值。

2. Task：调用方法不需要从异步方法中取返回值，但是希望检查异步方法的状态，那么可以选择可以返回 Task 类型的对象。不过，就算异步方法中包含 return 语句，也不会返回任何东西。

　　如【案例9】

复制代码

 1   2         //返回值为Task的方法3         private static async Task NewMethod9Async()4         {5 6             //下面的操作耗时3s7             HttpClient http = new HttpClient();8             var httpContent = new StringContent("", Encoding.UTF8, "application/json");9             //执行业务
10             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
11             Console.WriteLine("NewMethod9Async执行完成");
12         }

复制代码

复制代码

 1  　　　　　　#region 案例9(返回值为Task的异步方法)2             //结果是5s，说明异步方法和主线程的同步方法 在并行执行3             {4                 Stopwatch watch = Stopwatch.StartNew();5 6                 Console.WriteLine("开始执行");7                 Task t = NewMethod9Async();8 9                 Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任务状态
10                 Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任务完成状态标识
11                 Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任务是否有未处理的异常标识
12 
13                 //执行其他耗时操作，与此同时NewMethod9Async也在工作
14                 Thread.Sleep(5000);
15      
16                 Console.WriteLine("我是主业务");
17 
18                 t.Wait();
19 
20                 Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任务状态
21                 Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任务完成状态标识
22                 Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任务是否有未处理的异常标识
23 
24                 Console.WriteLine($"所有业务执行完成了");
25                 watch.Stop();
26                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
27             }
28             #endregion

复制代码

　　PS：对于Task返回值的异步方法，可以调用Wait(),等 待该异步方法执行完，他和await不同，await必须出现在async关键字封装的方法中。

3. void：调用异步执行方法，不需要做任何交互

　　如【案例10】

复制代码

 1     //返回值是Void的方法2         private static async void NewMethod10Async()3         {4             //下面的操作耗时5s5             HttpClient http = new HttpClient();6             var httpContent = new StringContent("", Encoding.UTF8, "application/json");7             //执行业务，假设这里主需要请求，不需要做任何交互8             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);9             Console.WriteLine("NewMethod10Async执行完成");
10         }

复制代码

复制代码

 1   　　　　　　#region 案例10(返回值为Void的异步方法)2             //结果是5s，说明异步方法和主线程的同步方法 在并行执行3             {4                 Stopwatch watch = Stopwatch.StartNew();5 6                 Console.WriteLine("开始执行");7                 NewMethod10Async();8 9                 //执行其他耗时操作，与此同时NewMethod9Async也在工作
10                 Thread.Sleep(5000);
11 
12                 Console.WriteLine("我是主业务");
13 
14 
15                 Console.WriteLine($"所有业务执行完成了");
16                 watch.Stop();
17                 Console.WriteLine($"耗时：{watch.ElapsedMilliseconds}");
18             }
19             #endregion

复制代码

四. 几个结论

1. 异步方法到底开不开起新线程？

　　异步和等待关键字不会导致其他线程创建。 因为异步方法本身并不会运行的线程，异步方法不需要多线程。 只有 + 当方法处于活动状态，则方法在当前同步上下文中运行并使用在线程的时间。 可以使用 Task.Run 移动 CPU 工作移到后台线程，但是，后台线程不利于等待结果变得可用处理。（来自MSDN原话）

2. async和await是一种异步编程模型，它本身并不能开启新线程，多用于将一些非阻止API或者开启新线程的操作封装起来，使其调用的时候像同步方法一样使用。

下面补充博客园dudu的解释，方便大家理解。

 

五. 参考资料

 　　1. 反骨仔：http://www.cnblogs.com/liqingwen/p/5831951.html

　　　　　　　 http://www.cnblogs.com/liqingwen/p/5844095.html

　　2. MSDN：https://msdn.microsoft.com/library/hh191443(vs.110).aspx

 

PS：如果你想了解多线程的其他知识，请移步：那些年我们一起追逐的多线程(Thread、ThreadPool、委托异步调用、Task/TaskFactory、Parallerl、async和await)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/438240.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

@PostConstruct注解

@PostConstruct注解

PostConstruct是Java自己的注解. PostConstruct该注解被用来修饰一个非静态的void()方法. PostConstruct修饰的方法会在服务器加载Servlet的时候运行,并且只会被服务器执行一次. PostConstruct在构造函数之后执行,init()方法之前执行. 执行顺序 Constructor >> Autow…
阅读更多...
springCloud五大组件--Gateway

springCloud五大组件--Gateway

SpringCloud Gateway 是 Spring Cloud 的一个全新项目&#xff0c;该项目是基于 Spring 5.0&#xff0c;Spring Boot 2.0 和 Project Reactor 等技术开发的网关&#xff0c;它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。 Spring Cloud Gateway 的目标&#…
阅读更多...
多线程篇（被替换）

多线程篇（被替换）

一. 背景 在刚接触开发的头几年里&#xff0c;说实话&#xff0c;根本不考虑多线程的这个问题&#xff0c;貌似那时候脑子里也有没有多线程的这个概念&#xff0c;所有的业务都是一个线程来处理&#xff0c;不考虑性能问题&#xff0c;当然也没有考虑多线程操作一条记录存在的并…
阅读更多...
springCloud五大组件--Eureka

springCloud五大组件--Eureka

Spring Cloud 支持了 Zookeeper、Consul 和 Eureka&#xff0c;官方推荐 Eureka。 C(一致性)A(高可用)P(分区容错)理论&#xff0c;Eureka的选择就是放弃C&#xff0c;选择AP。 Eureka 采用纯 Java 实现&#xff0c;除实现了注册中心基本的服务注册和发现之外&#xff0c;极大…
阅读更多...
.NET异步程序设计之任务并行库

.NET异步程序设计之任务并行库

目录 1.简介2.Parallel类 2.0 Parallel类简介2.1 Parallel.For()2.2 Parallel.ForEach()2.3 Parallel.Invoke()2.4 补充&#xff1a;线程安全集合3.Task类 3.0 Task类简介3.1 创建无返回值的Task任务3.2 创建有返回值的Task任务3.3 为Task添加延续任务3.4 Task.Delay3.5 Task对…
阅读更多...
Mysql主从延时解决办法

Mysql主从延时解决办法

1.忍受大法 第一种解决办法&#xff0c;很简单&#xff0c;无他&#xff0c;不管他&#xff0c;没有读到也没事。这时业务不需要任何改造&#xff0c;你好&#xff0c;我好&#xff0c;她也好~ 如果业务对于数据一致性要求不高&#xff0c;我们就可以采用这种方案。 2.数据同…
阅读更多...
关于C#程序的单元测试

关于C#程序的单元测试

目录 1.单元测试概念2.单元测试的原则3.单元测试简单示例4.单元测试框架特性标签5.单元测试中的断言Assert6.单元测试中验证预期的异常7.单元测试中针对状态的间接测试8.单元测试在MVC模式中的实现8.单元测试相关参考9.示例源代码下载 志铭-2020年1月23日 11:49:41 1.单元测试…
阅读更多...
NuGet是什么？理解与使用（上）

NuGet是什么？理解与使用（上）

如果你了解python&#xff0c;那么它类似pip。 如果你了解nodejs&#xff0c;那么它类似npm。 如果你了解ruby&#xff0c;那么它类似gem。 对&#xff0c;它就是一个包&#xff08;package&#xff09;管理平台&#xff0c;确切的说是 .net平台的包管理工具&#xff0c;它提…
阅读更多...
NuGet是什么？理解与使用（下）

NuGet是什么？理解与使用（下）

本篇将回答下面几个问题&#xff1a; 如何解读NuGet Gallery上的包信息&#xff1f;如何上传NuGet包到NuGet Gallery&#xff1f;如何安装本地NuGet包&#xff1f;NuGet包的内容文件与目录结构&#xff1f; 如果你没看过上篇那么它在这里&#xff1a; 6号咸鱼&#xff1a;NuG…
阅读更多...
C#多线程之旅(1)——介绍和基本概念

C#多线程之旅(1)——介绍和基本概念

阅读目录 一、多线程介绍二、Join 和Sleep三、线程怎样工作四、线程和进程五、线程的使用和误用一、多线程介绍 C#通过多线程支持并行执行的代码。一个线程是一个独立执行的路径&#xff0c;可以同时与其他线程一起运行。一个C#客户端程序(Console,WPF,Winows Forms)开始于一个…
阅读更多...
C#多线程之旅(2)——详解线程的开始和创建

C#多线程之旅(2)——详解线程的开始和创建

阅读目录 代码下载一、线程的创建和开始二、传递数据给一个线程三、命名线程四、前台线程和后台线程五、线程优先级六、异常处理代码下载 Thread_博客园_cnblogs_jackson0714.zip 第一篇~第三篇的代码示例&#xff1a; 源码地址&#xff1a;https://github.com/Jackson0714/T…
阅读更多...
C#多线程之旅(3)——线程池

C#多线程之旅(3)——线程池

阅读目录 代码下载一、介绍二、通过TPL进入线程池三、不用TPL进入到线程池v博客前言 先交代下背景&#xff0c;写《C#多线程之旅》这个系列文章主要是因为以下几个原因&#xff1a;1.多线程在C/S和B/S架构中用得是非常多的;2.而且多线程的使用是非常复杂的&#xff0c;如果没有…
阅读更多...
C#多线程之旅(4)——APM初探

C#多线程之旅(4)——APM初探

阅读目录 一、简单的串行执行程序 二、使用委托来实现APM源码地址&#xff1a;https://github.com/Jackson0714/Threads C#多线程之旅(4)——APM初探 v博客前言 先交代下背景&#xff0c;前面几张内容主要是介绍多线程的基本知识&#xff0c;这一章是因为正好接触到了APM&…
阅读更多...
C#多线程编程系列（五）- C# ConcurrentBag的实现原理

C#多线程编程系列（五）- C# ConcurrentBag的实现原理

目录 一、前言二、ConcurrentBag类三、 ConcurrentBag线程安全实现原理 1. ConcurrentBag的私有字段2. 用于数据存储的ThreadLocalList类3. ConcurrentBag实现新增元素4. ConcurrentBag 如何实现迭代器模式四、总结笔者水平有限&#xff0c;如果错误欢迎各位批评指正&#xff…
阅读更多...
C#多线程编程系列（五）- 浅析C# Dictionary实现原理

C#多线程编程系列（五）- 浅析C# Dictionary实现原理

目录 一、前言二、理论知识 1、Hash算法2、Hash桶算法3、解决冲突算法三、Dictionary实现 1. Entry结构体2. 其它关键私有变量3. Dictionary - Add操作4. Dictionary - Find操作5. Dictionary - Remove操作6. Dictionary - Resize操作(扩容)7. Dictionary - 再谈Add操作8. Col…
阅读更多...
ASP.NET MVC 入门5、View与ViewData

ASP.NET MVC 入门5、View与ViewData

本系列文章基于ASP.NET MVC Preview5. view在MVC模式中与用户进行最直接的接触&#xff0c;它负责数据的呈现。这里要注意一点就是&#xff0c;view只是负责数据的呈现&#xff0c;所以我们应该要尽量让view中不涉及业务逻辑的处理。 我们来添加一个Blog首页的view。在安装了…
阅读更多...
ASP.NET MVC 入门6、TempData

ASP.NET MVC 入门6、TempData

本系列文章基于ASP.NET MVC Preview5. ASP.NET MVC的TempData用于传输一些临时的数据&#xff0c;例如在各个控制器Action间传递临时的数据或者给View传递一些临时的数据&#xff0c;相信大家都看过“在ASP.NET页面间传值的方法有哪几种”这个面试题&#xff0c;在ASP.NET MVC…
阅读更多...
ASP.NET MVC 入门11、使用AJAX

ASP.NET MVC 入门11、使用AJAX

本系列文章基于ASP.NET MVC beta.本示例Blog系统同步更新的演示站点&#xff1a;http://4mvcblog.qsh.in/ 在ASP.NET MVC beta发布之前&#xff0c;M$就宣布支持开源的JS框架jQuery&#xff0c;然后ASP.NET MVC beta发布后&#xff0c;你建立一个ASP.NET MVC beta的项目后&…
阅读更多...
Nacos 使用

Nacos 使用

环境准备 64 bit OS&#xff0c;支持 Linux/Unix/Mac/Windows&#xff0c;推荐选用 Linux/Unix/Mac。64 bit JDK 1.8&#xff1b;下载 & 配置。Maven 3.2.x&#xff1b;下载 & 配置。 下载 Nacos 并启动 Nacos server。 启动配置管理 启动了 Nacos server 后&#x…
阅读更多...
四种并发编程模型简介

四种并发编程模型简介

概述 并发往往和并行一起被提及&#xff0c;但是我们应该明确的是“并发”不等同于“并行” • 并发 &#xff1a;同一时间 对待 多件事情 &#xff08;逻辑层面&#xff09; • 并行 &#xff1a;同一时间 做(执行) 多件事情 (物理层面) 并发可以构造出一种问题解…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023