博客园_Dozer .NET 技术博客

不要在 ASP.NET 4.5 Beta 的 Page 类事件上直接使用 async 与 await

2012-03-14T12:10:00Z

欢迎到我的博客中阅读独立版本：http://www.dozer.cc/2012/03/async-and-await-in-asp-net-beta/

发现问题

在我的上一篇文章《async 与 await 在 Web 下的应用》中，我提到了 asp.net 4.5 在 Web.Config 中的一个奇怪配置：

在 Stack Overflow 上提问后，终于有人回答我了。

看了别人的回复后，才发现了我上篇文章中的问题。

下面代码中的这种用法是错误的：

protected async void Page_Load(object sender, EventArgs e)
{
WebClient client = new WebClient();
var result1 = await client.DownloadStringTaskAsync("http://www.website.com");
WebClient client2 = new WebClient();
var result2 = await client.DownloadStringTaskAsync(result1);
//do more
}

在事件上直接使用 async 引发的错误

代码段一：

public partial class WebForm1 : System.Web.UI.Page
{
protected string Msg { get; set; }
protected async void Page_Load(object sender, EventArgs e)
{
using (WebService service = new WebService())
{
Msg = await service.Method1TaskSync();
}
}

protected async void Button_Test_Click(object sender, EventArgs e)
{
using (WebService service = new WebService())
{
Msg = await service.Method2TaskSync();
}
}
}

试问，最后的 Msg 的值是什么？应该是哪个方法的返回值？

如果去掉异步，那答案肯定是 Method2。那加上异步后呢？

这里用的是 async 和 await 来实现了异步，所以逻辑上的先后次序应该和代码上的先后次序一样。

但是上述代码两个事件会一起执行！导致了一定的问题！

总结一下上面代码的问题：当页面中的 Page_Load 事件和别的事件都用了 async 和 await 后会出现执行次序错误、死锁等问题。它们并不会按次序执行。

代码段二：

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="AsyncAwait.WebForm1"
Async="true" %>

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<%:Msg %>
</div>
</form>
</body>
</html>

后端代码和上面一样的代码，只不过把 UseTaskFriendlySynchronizationContext 的配置改成了 true，并且把数据显示到了页面上。

执行后发现：根本无法显示内容，页面在异步执行结束前就已经输出完毕了。

UseTaskFriendlySynchronizationContext 的作用和错误引发的原因

其实在老外的回答中已经说明了全部，我这里主要是翻译+精简一下。

UseTaskFriendlySynchronizationContext 的作用：

之前版本的 asp.net 所使用的异步不符合 CLR 的规范，而只有 RegisterAsyncTask 这个方法是符合 CLR 规范的。

所以 asp.net 4.5 中，加入这个新的配置是为了禁用掉之前不符合约定的功能，只要把这个配置设置为了 true，别的异步方案全部会失效。（代码段二主要就是演示了这个现象）

引发错误的原因：

async 和 await 关键字在底层主要是利用 SynchronizationContext 来实现了异步。（具体原理我也没研究过）

而这个方案首先不符合 CLR 规范，另外也会引起很多问题。（代码段一主要就是演示了其中一个问题）

目前正确的写法

首先，建议把 UseTaskFriendlySynchronizationContext 设置为 true。

另外，正确的写法如下：

public partial class WebForm1 : System.Web.UI.Page
{
protected string Msg { get; set; }
protected void Page_Load(object sender, EventArgs e)
{
RegisterAsyncTask(new PageAsyncTask(Method1));

}
private async Task Method1()
{
using (WebService service = new WebService())
{
Msg = await service.HelloWorldTaskSync();
}
}

protected void Button_Test_Click(object sender, EventArgs e)
{
RegisterAsyncTask(new PageAsyncTask(Method2));
}

private async Task Method2()
{
using (WebService service = new WebService())
{
Msg = await service.HelloWorldTaskSync();
}
}
}

如果需要写异步，一定要用 RegisterAsyncTask 方法，实测证明，支持多次调用，而且会按次序执行。

老外说了，他们也想直接在事件上加 async 来写，但是由于技术原因并没有实现，希望在正式版或者未来的版本中可以实现吧！

参考资料：

http://stackoverflow.com/questions/9562836/whats-the-meaning-of-usetaskfriendlysynchronizationcontext

http://social.msdn.microsoft.com/Forums/en-NZ/async/thread/b2e8c51e-2808-46d0-92e9-b825321d0af8

本文链接

async 与 await 在 Web 下的应用

2012-03-06T11:39:00Z

原文地址：http://www.dozer.cc/2012/03/async-and-await-in-web-application/

欢迎大家到我的博客中查看，排版会更舒服一点！

.net 中的异步

关于 .net 的异步，一篇文章是讲不完的，我这里就贴两篇文章让大家看一下：

《正确使用异步操作》、《C#客户端的异步操作》、《细说ASP.NET的各种异步操作》

另外，在 .net 4.0 中还推出了新的任务并行库（TPL），也是一种新异步模式：

《任务并行库》

最后，.net 4.5 又推出了全新的 async 和 await 关键字：

《C#与Visual Basic的未来（上）》

《C#与Visual Basic的未来（中）》

《C#与Visual Basic的未来（下）》

最后，在这几篇文章的基础上，想和大家谈谈 async 和 await 在 Web 下的应用，包括 WebForm 和 MVC。

async 与 await 的简单介绍

仔细看完老赵的《C#与Visual Basic的未来》大家应该都能明白这两个关键字的作用是什么了。

适用条件：只能适用于TPL异步模式

传统的方法返回的就是需要返回的内容，而基于TPL模式的异步，返回的都是 Task<T>，其中的 T 类型就是你需要返回内容的类型。

在 Visual Studio 11 中，只要你调用的某个方法返回的类型是 Task 或者 Task<T>，它就会提示这是一个可等待的方法。

这时候，就可以利用 async 和 await 关键字了。

场景：解决基于事件的异步中回调函数嵌套使用中的问题

假设有这样一个场景，一个 C# 应用程序中（WinForm Or WPF）我需要从一个网站上下载一个内容，然后再根据内容里的网址再下载里面的内容。

如果直接利用 WebClient 的 DownloadString 方法，很明显 UI 线程会被阻塞，没人会这么做。

如果只是一次下载，那利用 WebClient 的 DownloadStringAsync 就可以轻松解决了，但是如果是想这样需要两次下载，而且两次下载是有关联的呢？如果是三次四次呢？

我们先来看看用基于事件的异步来实现：

protected void DownloadAsync()
{
WebClient client = new WebClient();
client.DownloadStringCompleted += client_DownloadStringCompleted;
client.DownloadStringAsync(new Uri("http://www.website.com"));
}
void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
WebClient client = new WebClient();
client.DownloadStringCompleted+=client_DownloadStringCompleted2;
client.DownloadStringAsync(new Uri(e.Result));
}
void client_DownloadStringCompleted2(object sender, DownloadStringCompletedEventArgs e)
{
var result = e.Result;//最终结果
//do more
}

下面再来看看用 async 和 await 来实现：

protected async void DownloadTaskAsync() {
WebClient client = new WebClient();
var result1 = await client.DownloadStringTaskAsync("http://www.website.com");
WebClient client2 = new WebClient();
var result2 = await client.DownloadStringTaskAsync(result1);
//do more
}

是不是简单多了？

在 WebForm 和 MVC 中使用 async 和 await

在 .net 4.5 中，最新的 WebForm 和 MVC 都已经支持这两个关键字了。

在 asp.net WebForm 中：

首先新建一个页面
打开 aspx 文件，然后再顶部的属性中加入：Async="true"
接下来在任何一个事件中，加入这两个关键字即可
另外在 Web.Config 中有两个奇怪的配置，有可能会导致出错，去掉有正常，这两个配置具体有什么用，我已经在 StackOverFlow 上问别人了

在 asp.net MVC 中：

把原来继承于 Controller 改成继承于 AsyncController

在方法前加上 async，并把返回类型改成 Task<T>

public class HomeController : AsyncController
{
public async Task<ActionResult> Test()
{
var result = await Task.Run(() =>
{
Thread.Sleep(5000);
return "hello";
});
return Content(result);
}
}

在 IHttpHandlder 中：

微软官方的 .net 4.5 releace note 中已经提到了：

public class MyAsyncHandler : HttpTaskAsyncHandler
{
// ...

// ASP.NET automatically takes care of integrating the Task based override
// with the ASP.NET pipeline.
public override async Task ProcessRequestAsync(HttpContext context)
{
WebClient wc = new WebClient();
var result = await
wc.DownloadStringTaskAsync("http://www.microsoft.com");
// Do something with the result
}
}

在 IHttpModule 中：

同样是微软官方的 .net 4.5 releace note 中，实现起来有点复杂，大家可以自己去看看。

在 Web 应用程序中使用 async 和 await 的注意事项

其实不仅仅是使用这两个关键字的注意事项，而是在 Web 中只要用到了异步页，就要注意一下问题！

Web 本来就是多线程的，为什么还要用异步编程？

多线程只是实现异步的一种手段，的确，Web 本来就是多线程的，所以在很多时候不用异步也没什么问题。一般也不会有问题，只是有更好的方案。

大家看完《正确使用异步操作》后就会知道，异步有多种实现方式，但是它们底层只有两种类型，一种是：“Compute-Bound Operation”，另一种是“IO-Bound Operation”。（具体的可以到文中查看）

在 Web 中，使用异步去处理“Compute-Bound Operation”是没有意义的，因为 Web 本来就是多线程的，这样做没有任何效率上的提升。（除非你在处理这个异步的时候，不需要等待这个异步执行结束就可以返回页面内容）

所以，在 Web 中，只有当你需要面对“IO-Bound Operation”的时候，去用异步页才是真的有用的。因为它是在等待磁盘或者网络响应，并不占据资源，甚至不占据工作线程。

如何区分呢？那篇文章中已经写了，另外，大部分和磁盘&网络打交道的异步操作都是“IO-Bound Operation”的。

但是，如果你真的想要提升效率，还需要你亲自去测试一下，因为要实现“IO-Bound Operation”有一定的条件。

WebClient、WebService 和 WCF 支持吗？

经过测试，上面这三种 Web 应用程序中使用最多的，是支持“IO-Bound Operation”的。其中，在 .net 4.5 中，WebClient 和 WCF 可以直接支持 async 和 await 关键字。（因为它们有相关的方法可以返回 Task 对象）

而 WebService（微软不建议使用，但实际上还在被大量的应用），却不支持，但是可以通过写一些代码后让它支持。

数据库操作支持吗？

经过一定的配置后，它是可以支持的，但是具体的还需要进行大量的测试，毕竟不是调用几个方法那么简单。

如何把传统的异步模式转换成 TPL 模式，以实现 async 和 await

上面提到了 WebService 并没有实现 TPL 模式，在 .net 4.5 中引用 WebService 后实现的是基于事件的异步。

（.net 2.0 以上程序在引用 WebService 的时候，需要点“添加服务引用”——“高级”——“添加Web引用”，如果直接在服务引用中添加，会出现一定的问题。并且，就算你添加了，它也没有帮你实现基于 TPL 的异步。）

如何把 APM 模式转换成 TPL 模式？

其实微软在这篇文章中已经写过如何把传统的异步模式转换成 TPL 模式了：TPL 和传统 .NET 异步编程

其中 APM 转 TPL 比较简单，我就不多介绍了。

如何把 EAP 模式转换成 TPL 模式？

EAP 就是基于事件的异步，上面那篇文章中其实也提到了，但是写的并不是很清楚。

下面我用一段简化的代码来实现 EAP 转 TPL：

namespace WebServiceAdapter.MyWebService
{
public partial class WebService
{
/// <summary>
/// 无 CancellationToken 的调用
/// </summary>
/// <returns></returns>
public Task<string> HelloWorldTaskSync()
{
return HelloWorldTaskSync(new CancellationToken());
}

/// <summary>
/// 有 CancellationToken 的调用
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public Task<string> HelloWorldTaskSync(CancellationToken token)
{
TaskCompletionSource<string> tcs = new TaskCompletionSource<string>();

token.Register(() =>
{
//注册 CancellationToken
this.CancelAsync(null);
});

//注册完成事件
this.HelloWorldCompleted += (object sender, HelloWorldCompletedEventArgs args) =>
{
if (args.Cancelled == true)
{
tcs.TrySetCanceled();
return;
}
else if (args.Error != null)
{
tcs.TrySetException(args.Error);
return;
}
else
{
tcs.TrySetResult(args.Result);
}
};

//异步调用
this.HelloWorldAsync();

//返回 Task
return tcs.Task;
}
}
}

转换好后再去配合使用 async 和 await 关键字就方便多了：

protected async void Page_Load(object sender, EventArgs e)
{
using (WebService service = new WebService())
{
await service.HelloWorldTaskSync();
}
}

性能测试

前期准备：

理论和实际代码都讲完了，是不是该拿出点东西来验证一下了？

在做性能测试的时候我绕了很多弯路，碰到了很多问题，一度让我怀疑它是不是真的可以提升性能。

但最终还是解决了！感谢老赵的一篇文章：体会ASP.NET异步处理请求的效果

异步页最大的用处就是在处理“IO-Bound Operation”的时候可以不占据工作线程。

测试的理论：

限制网站应用程序的工作线程，然后同时请求一个页面，请求数大于工作线程数。
请求的页面会访问一个 WebService ，这个 WebService 会延迟5秒，对于网站来说，这个5秒就是“IO-Bound Operation”。
如果限制了工作线程数后，异步页所有请求都可以在5秒完成，那说明的确没有占据工作线程。反之则说明理论错误！

我一开始限制的工作线程是10，然后同时请求50，但是无论是异步页还是同步页，总耗时都差不多…

后来仔细看老赵的文章才发现，原来在 Vista & Win7 中最大请求数被限制在10了，所以多于10的请求根本没到达网站应用程序。

最后我把工作线程限制在2，然后同时请求10，终于得到了正确的理论数据！

工具准备：

我这里用的工具是 apache 下那只的 ab.exe，简单好用！

另外我也写了相关的代码来支持测试。

开始测试：

运行 WebService，提供一个会延时5秒的服务。

然后运行网站，有三个页面：

NoAsyncPage.aspx ：传统的页面
AsyncPage_IO.aspx：异步页面，和传统页面一样，都是调用 WebService ，但是是用异步调用
AsyncPage_CPU.aspx：为了验证在异步中执行“Compute-Bound Operation”是没有意义的

在CMD中，依次用 ab.exe 调用这三个页面：

ab -c 10 -n 10 http://localhost:6360/noasyncpage.aspx
ab -c 10 -n 10 http://localhost:6360/asyncpage_io.aspx
ab -c 10 -n 10 http://localhost:6360/asyncpage_cpu.aspx

最终运行结果如下：

NoAsyncPage.aspx ：26.39秒
AsyncPage_IO.aspx：5.29秒
AsyncPage_CPU.aspx：26.54秒

数据分析：

仔细分析下数据，会发现都符合理论：

NoAsyncPage.aspx ：没有采用异步，2个工作线程，10个请求，总事件在10*5/2=25左右。
AsyncPage_IO.aspx：采用异步页，不占据工作线程，10个请求同时执行。
AsyncPage_CPU.aspx：虽然采用了异步页，但是异步的时候依然占据了一个工作线程，而且还多了一些新建线程，切换线程的损耗。

最终结果非常让人满意，特别是AsyncPage_IO.aspx，如果我们把访问量大，并且需要等在磁盘或者是网络的页面都改写成这样，那可以大大减少IIS管线的消耗！

源代码和工具下载

AsyncSample

请用 Visual Studio 11 打开

本文链接

短函数的优点

2012-01-22T14:26:00Z

函数最初的用处
大家刚学编程的时候，一定还记得为什么要用函数。那就是把重复的代码归纳到一个函数中多次利用。这点毋庸置疑，大家也用的很熟了，但是除了这个还有什么改进空间吗？答案肯定是有的！
PS.本文不讨论面向对象、不讨论设计模式，只是把视线聚焦在 Class 内部的函数上。

出现什么问题了？
大家都知道当一个函数很长的时候，就会造成阅读困难，那以前我们都是怎么解决的呢？
写注释：这个大家都知道怎么用，也是一种有效的方法。
用 #region 代码块：这个也是一个行之有效的方法。
还有什么别的方法吗？其实还有一个方法就是文章的标题：使用短函数。
在讨论短函数有点之前，我想先用一点篇幅来讲述一下什么时候改写注释。
路人甲：纳尼？不是说任何时候都要写注释吗？

什么时候该写注释
函数主要就有两个用途：
在 Class 和别的函数、字段、属性前打三个 / ，就会自动生成供 VS 使用的智能提示内容。
解释代码意图。
第一点大家都会用，而且就这么用，没有什么替代的办法。
但是关于第二点，注释未必是最好的解决办法。
因为如果一段代码让人看不懂，要么就是“英文看不懂”，要么就是“逻辑复杂”。

注释是为了弥补它们带来的缺点，但是为什么不从根本解决呢？
“英文看不懂”：每个程序员都应该有一定的英文基础吧？另外注意命名规范，就可以解决了。
“逻辑复杂”：如果一段程序逻辑复杂，让人看不懂，你觉得你应该费力地去给别人解释呢？还是自己好好整理整理，把代码梳理一下呢？
那怎么梳理你的代码呢？短函数？

短函数的优点——有助于梳理代码
我想废话不多说了，都是程序员，大家一看代码就明白了。
这里贴上另外一篇文章：《代码才是最好的注释》
文章的题目是代码才是最好的注释，其实写的就是短函数的优点。
已经有了文章，我就不重复工作了。
顺便提一下 region ，其实 region 在 VS 下的收缩功能可以达到差不多的效果，你可以选用这个，但是不是很推荐。
下面，我还要和大家探讨一下另一个优点。

短函数的优点——在 .Net 下可优化性能
关于这点，我是在《More Effective C#》中看到的，觉得非常好，所以推荐给大家。
把一个大函数拆分成很多小函数可以优化性能？这点看上去很可笑。是的，其实这点性能的提升微不足道，但是如果可以，为什么不做呢？更何况这样做还有上面说的另一个优点。
为什么长函数分割成短函数的时候可以优化 .Net 下的性能呢？

你首先要明白：
.Net 下的语言编译的时候只是编译成了中间语言。运行的时候，它会再一次编译成机器码。
这个中间语言编译成机器码是以一个函数为基本代为的。也就是说，每次调用函数的时候，这个函数才会被编译。

那长函数分割成了短函数有优势吗？代码量不还是一样的？纯粹的分割反而会产生更多的代码呢！
的确如此，所以说，这里还有另一个条件：当这个长函数中有很多分支的时候。
1
2
3
4
5
6
7
8
9
10
11
`public` `void` `Func1()`
`{`
    `if(xxxx)`
    `{`
        `//代码段1，几百行`
    `}`
    `else`
    `{`
        `//代码段2，几百行`
    `}`
`}`
上面这段代码，有两大段代码，每次调用这个函数其实只会执行一部分。
所以，如果把这两块代码段提取出来，编译的过程中就会少编译一半的代码。
现在明白在什么时候把长函数分割成短函数能优化性能了吧。

虽然这点性能提升并不明显，但是，如果你一个函数中，有一个很大的分支。
你在看代码的过程中，一定会看花眼，滚屏的过程中，都不知道自己现在身处在哪个部分。
随意就算不考虑性能，也推荐把这样的代码分割成短函数！

总结
上文说了短函数的优点，说了下注释的缺陷，还有一个没怎么提到的 region …
我在写代码的时候一般遵循一下原则：
函数内部一般不写注释，如果“逻辑复杂”，我会优化逻辑并分割成短函数。
在一些算法中，包含很奇特的公式，这个一定要写注释了，没办法分割和优化。
写完函数后查看是否有大段的分支，有的话再分割成短函数。
最后，希望本文能对大家有用！

你也可以到我的个人博客中查看此文：短函数的优点
本文链接

把 ref 和 out 关键字说透

2011-10-28T09:03:00Z

如果排版不好，可以到我个人博客上看，我是现在个人博客上写的，欢迎捧场^^：http://www.dozer.cc

ref 和 out 的区别

网上有很多这方面的文章，但是大部分人总是纠结于他们在原理上的那一点点细微的区别，所以导致了难以区分它们，也不知道什么时候改用哪一个了。

但是如果从试用场景的角度对它们进行区别的话，以后你一定不会再纠结了。

当你明白它们的适用场景后，再去扣其中的原理，使用中的一些问题也就迎刃而解了~

简单的来说，它们的区别在于：

ref 关键字是作用是把一个变量的引用传入函数，和 C/C++ 中的指针几乎一样，就是传入了这个变量的栈指针。

out 关键字的作用是当你需要返回多个变量的时候，可以把一个变量加上 out 关键字，并在函数内对它赋值，以实现返回多个变量。

几个简单的演示

上面说了 ref 和 out 的作用，非常简单，但是在具体使用的时候却遇到了很多麻烦，因为 C# 中本身就区分了引用类型和值类型。

我先举几个例子，来看看会出现哪些诡异的情况

代码段一：

static void Main(string[] args)
{
    int a;
    Test1(out a);//编译通过
 
    int b;
    Test2(ref b);//编译失败
}
 
static void Test1(out int a)
{
    a = 1;
}
static void Test2(ref int b)
{
    b = 1;
}

这两个关键字看起来用法一样，为什么会有合格现象？

网上的答案很简单：out 关键字在传入前可以不赋值，ref 关键字在传入前一定要赋值。

这是什么解释？受之于鱼但并没有授之予渔！这到底是为什么呢？

想知道背后真正原理的呢，就继续看下去吧，后面我讲会讲到这里的区别。

代码二：

static void Main(string[] args)
{
    object a = new object(), b = new object(), c = new object();
 
    Test1(out a);
    Test2(ref b);
    Test3(c);
    //最终 a,b,c 分别是什么？
    //a,b = null
    //c 还是 object
}
 
static void Test1(out object a)
{
    a = null;
}
static void Test2(ref object b)
{
    b = null;
}
static void Test3(object c)
{
    c = null;
}

新建三个 object，object是引用类型；三个函数，分别是 out,ref和普通调用；执行了一样的语句；最后的结果为什么是这样呢？

如果你只是从浅层次理解了 out 和 ref 的区别，这个问题你一定回答不上了。（我以前也不知道）

所以，这是为什么呢？继续往下看。

^_^ 相信很多人晕了，我的目的达到了。（邪恶的笑~~）

那么，下面，我为大家从两个角度来分析一下。

对于值类型来说，加 out、加 ref 和什么都不加有什么共同点和区别？

对于引用类型来说，加 out、加 ref 和什么都不加有什么共同点和区别？

问题一：关于值类型

普通的传递值类型很简单了，传的只是一个值，没难度，平时都是这么用的，很好区分，所以这里就不惨和进去了。

接下来是 ref 和 out 的区别，为什么要了解区别呢？当然是为了了解怎么用它们，简单的来说就是需要了解：什么时候该用哪个。

个人总结有几个原则：

如果你是为了能多返回一个变量，那么就应该用 out：

用 out 关键字有几个好处：可以不关心函数外是否被赋值，并且如果在函数内没有赋值的话就会编译不通过。（提醒你一定要返回）

你可以把它当成是另一种形式的 return 来用，我们来做一个类比：

return 语句的特点：接收 return 的变量事先不需要赋值（当然如果赋值了也没关系），在函数内必须 return。

可以看到 out 关键字的作用、行为、特点和 return 是完全一样的。因为它当初设计的目的就是为了解决这个问题的。

如果你想要像引用类型那样调用值类型，那你就可以 ref：

传入值类型的引用后，你可以用它，也可以不用它，你也可以重新修改它的各个属性，而函数外也可以随之改变。

我们来把 “传值类型的引用” 和 “传引用类型” 来做一个类比：

static void Main(string[] args)
{
    int a;
    Test1(ref a);//错误   1   使用了未赋值的局部变量“a”
 
    object b;
    Test2(b);//错误   2   使用了未赋值的局部变量“b”
}
static void Test1(ref int a) { }
 
static void Test2(object b) { }

传入加了 ref 的值类型和传入一个引用类型的作用、行为、特点都是类似的。

同样，他们同时要遵守一个原则：传入前必须赋值，这个是为什么呢？

如果赋值后，传入两个函数的分别是 int a 的指针和 object b 的指针。

而不赋值的话，a 和 b 根本还不存在，那它们又怎么会有地址呢？

注意：如果你只写了 object a ，而在后面的代码中没有赋值，它并没有真正地分配内存。

我们可以看一下三个操作的 IL 代码：

private static void Main(string[] args)
{
    //IL_0000: nop
    object a;//没做任何事
 
    //IL_0002: ldnull
    //IL_0003: stloc.1
    object b = null;//在栈中增加了一个指针，指向 null
 
    //IL_0004: newobj instance void [mscorlib]System.Object::.ctor()
    //IL_0009: stloc.2
    object c = new object();//在栈中增加了一个指针，指向新建的 object 对象
}

传入引用类型的目的是把一个已经存在的对象的地址传过去，而如果你只是进行了 object a 声明，并没做复制，这行代码跟没做任何事！

所以，除非你使用了 out 关键字，在不用关键字和用 ref 关键字的情况下，你都必须事先复制。 out 只是一种特殊的 return

总结：

现在你是否明白，当变量什么情况下该用什么关键字了吗？其实有时候 ref 和 out 都可以达到目的，你需要根据你的初衷，和它们的特点，来衡量一下到底使用哪个了！

另外，我们来看看两个同样的函数，用 out 和 ref 时候的 IL 代码

原函数：

private static void Test1(out int a)
{
    a = 1;
}
private static void Test2(ref int a)
{
    a = 1;
}

IL代码：

.method private hidebysig static
    void Test1 (
        [out] int32& a
    ) cil managed
{
    // Method begins at RVA 0x2053
    // Code size 5 (0x5)
    .maxstack 8
 
    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: ldc.i4.1
    IL_0003: stind.i4
    IL_0004: ret
} // end of method Program::Test1
 
.method private hidebysig static
    void Test2 (
        int32& a
    ) cil managed
{
    // Method begins at RVA 0x2059
    // Code size 5 (0x5)
    .maxstack 8
 
    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: ldc.i4.1
    IL_0003: stind.i4
    IL_0004: ret
} // end of method Program::Test2

发现了吗？它们在函数内部完全是一样的！因为他们的原理都是传入了这个变量的引用。只是 out 关键字前面出现了一个标记 [out]

它们在原理上的区别主要在于编译器对它们进行了一定的限制。

最上面“代码段一”中的问题你现在明白了吗？

问题二：关于引用类型

对于值类型来说，最难区别的是 ref 和 out，而对于引用类型来说就不同了。

首先，引用类型传的是引用，加了 ref 以后也是引用，所以它们是一样的？暂时我们就这么认为吧~ 我们暂时认为它们是一样的，并统称为：传引用。

所以，对于引用类型来说，out 和传引用的区别跟对于值类型传 ref 和 out 的区别类似，具体适用场景也和值类型类似，所以就不多加阐述了。

虽然我们说直接传和加 ref 都可以统称为传引用，但是它们还是有区别的！而且是一个很隐蔽的区别。

我们再来看一下最上面的代码段二：

static void Main(string[] args)
{
    object a = new object(), b = new object(), c = new object();
 
    Test1(out a);
    Test2(ref b);
    Test3(c);
    //最终 a,b,c 分别是什么？
    //a,b = null
    //c 还是 object
}
 
static void Test1(out object a)
{
    a = null;
}
static void Test2(ref object b)
{
    b = null;
}
static void Test3(object c)
{
    c = null;
}

out 关键字就相当于 return ，所以内部赋值为 null ，就相当于 return 了 null

可是，为什么引用类型还要加 ref 呢？它本身部已经是引用了吗？为什么加了以后就会有天大的区别呢？！

用一句话概括就是：不加 ref 的引用是堆引用，而加了 ref 后就是栈引用！ @_@ 好搞啊。。什么跟什么？让我们一步步说清楚吧！

正常的传递引用类型：

加了 ref 的传递引用类型：

这两张图对于上面那句话的解释很清楚了吧？

如果直接传，只是分配了一个新的栈空间，存放着同一个地址，指向同一个对象。

内外指向的都是同一个对象，所以对对象内部的操作都是同步的。

但是，如果把函数内部的 obj2 赋值了 null，只是修改了 obj2 的引用，而 obj1 依然是引用了原来的对象。

所以上面的例子中，外部的变量并没有收到影响。

同样，如果内部的对象作了 obj2 = new object() 操作以后，也不会对外部的对象产生任何影响！

而加了 ref 后，传入的不是 object 地址，传入的是 object 地址的地址！

所以，当你对 obj2 赋 null 值的时候，其实是修改了 obj1 的地址，而自身的地址没变，还是引用到了 obj1

虽然在函数内部的语句是一样的，其实内部机制完全不同。我们可以看一下IL代码，一看就知道了！

.method private hidebysig static
    void Test1 (
        object a
    ) cil managed
{
    // Method begins at RVA 0x2053
    // Code size 5 (0x5)
    .maxstack 8
 
    IL_0000: nop
    IL_0001: ldnull
    IL_0002: starg.s a
    IL_0004: ret
} // end of method Program::Test1
 
.method private hidebysig static
    void Test2 (
        object& a
    ) cil managed
{
    // Method begins at RVA 0x2059
    // Code size 5 (0x5)
    .maxstack 8
 
    IL_0000: nop
    IL_0001: ldarg.0//多了这行代码
    IL_0002: ldnull
    IL_0003: stind.ref
    IL_0004: ret
} // end of method Program::Test2

上面是直接传入，并赋 null 值的

下面是加 ref 的

我们可以发现仅仅是多了一行代码：IL_0001: ldarg.0

其实，这样代码的作用就是讲参数0加载到堆栈上，也就是先根据引用，找到了外部的变量，然后再根据外部的变量，找到了最终的对象！

那现在你知道什么时候该加 ref，什么时候不用加 ref 了吗？

再看了一个例子：

private static void Test1(List<int> list)
{
    list.Clear();
}
private static void Test2(ref List<int> list)
{
    list = new List<int>();
}

同样是清空一个 List，如果没加 ref ，只能用 clear。

而加了 ref 后可以直接 new 一个新的~

如果你没加 ref 就直接 new 一个新的了，抱歉，外部根本不知道有这个东西，你们操作的将不是同一个 List

所以，你一定要了解这点，并注意一下几件事：

1、一般情况下不要用 ref

2、如果你没加 ref，千万别直接给它赋值，因为外面会接收不到…

现在你全部明白了吗？^_^

原文地址：把 ref 和 out 关键字说透

本文链接

不继承 IEnumerable 或 IQueryable 的类型怎么使用 LINQ 查询

2011-08-06T16:21:00Z

【摘要】最近想研究如何自定义 LINQ Provider ，但是一直无法入手，先写点收获吧~MSDN 上的这篇文章（《启用数据源以进行 LINQ 查询》）中写到：如果想对自己的数据源进行 LINQ 查询，那必须使用一下四种方法的其中一种。实现 IEnumerable 接口实现标准的查询方法实现 IQueryable 接口扩展已经实现的 LINQ 查询看到其中第二条，让人心生疑惑，那下面就来探讨一下吧~ http://www.cnblogs.com/dozer/archive/2011/08/07/to-enable-custom-linq-querying-of-generic-type.html

本文链接

MVC 下导航高亮的一种解决方案

2011-03-21T06:07:00Z

前言

导航高亮一直是一个让大家头疼的问题。

纯 Javascript 的话可以判断当前页面的地址和链接地址是否有关系。

这样的弊端就是自由度太低，MVC 下会出一定的问题（MVC 下有默认的 Controller 和 Action）

另一种方案是前端后端结合，为每一张页面设置一个属性，然后在页面中判断。满足条件便高亮。

这样的弊端就是，需要为你所有的页面设置属性，非常麻烦！

那么有没有什么完美的解决方案？一劳永逸的？

神奇的 eval 函数

Javascript 有精粹也有糟粕，其中的 eval 是大多数动态语言都拥有的精髓。我们是否可以利用这个函数呢？

基本思路：

给每一个 li（对应一个链接）设置一个 class，例如 class=”controller_Home”，

代表着，只要这张页面是的 controller 是 Home，就让这个链接高亮。

而在页面中，是可以通过代码直接得到 controller 和 action 的名称的，没必要为每一张页面单独手动设置。

解决方案

<ul id="top-navigation">
    <li class="controller_Home"><span><span>@Html.ActionLink("首页","Index","Home")</span></span></li>
    <li class="controller_Article"><span><span>@Html.ActionLink("文章管理","Index","Article")</span></span></li>
    <li class="controller_User"><span><span>@Html.ActionLink("用户管理","Index","User")</span></span></li>
</ul>
<input id="controller" type="hidden" value="@Html.ViewContext.RouteData.Values["controller"]"/>
<input id="action" type="hidden" value="@Html.ViewContext.RouteData.Values["action"]"/>

View 中的代码如上所示：

首先给所有的 li 加上一个 class
然后再利用两个 hidden ，把 controller 和 action 的名字放到前端页面中

$(function () {
    SetNavClass('top-navigation', 'active');
});
 
function SetNavClass(ulId, className) {
    controller = $('#controller').val();
    action = $('#action').val();
    eval('controller_' + controller + ' = true');
    eval('action_' + action + ' = true');
    list = $('#' + ulId + '>li');
 
    for (var k = 0; k < list.length; k++) {
        item = list[k];
        str = GetClassName(item);
        try {
            if (eval(str)) $(item).addClass(className);
        } catch (e) { }
    }
}
function GetClassName(item) {
    classes = $(item).attr('class').split(' ');
    for (var k = 0; k < classes.length; k++) {
        if (classes[k].indexOf('controller') > -1 || classes[k].indexOf('action') > -1) return classes[k];
    }
}

以上是 Javascript 的代码：

读取 controller 和 action 的名字
利用 eval 函数给 controller_[controller名字] 和 action_[action名字] 这两个变量赋值
取出 class 中的表达式
利用 eval 函数执行表达式，判断最后的结果，如果满足条件就加上高亮的 class

上述代码不需要为每个页面编写，只需要在母版页中编写一次即可，再引用这段 Javascript 函数。

如果你的 ul ID 和高亮 class 名字不一样，那么只要在调用这个函数的时候传入你自己的就行了。

高级应用

就这么简单？仅此而已？

如果真的是这样，那么完全可以直接利用 Javascript 判断页面地址来实现。

那么让我们来玩一些好玩的吧~

因为是 eval 函数，所以完全可以在这个 class 中编写复杂的表达式（其实就是 Javascript 表达式）

<li class="controller_Home||controller_About"><span><span>@Html.ActionLink("首页", "Index", "Home")</span></span></li>
<li class="controller_Article&&action_Add"><span><span>@Html.ActionLink("文章管理", "Index", "Article")</span></span></li>

以上两行代码表示：

controller 只要是 Home，或者 About，都会激活这个链接
controller 必须是 Article，action 必须是 Add

也就是说，在这个 class 里可以输入复杂的 Javascript，这样就可以实现复杂的导航激活功能了！

原文地址：MVC 下导航高亮的完美解决方案 (原文就是我自己的博客~ 所以是原创，不是转载~)

本文链接

深入研究 UCenter API

2011-01-26T15:47:00Z

目录：
开篇
通讯原理：UCenter API 与子站之间的通讯原理和单点登陆原理
加密与解密：AuthCode详解 & AuthCode函数翻译过程中的注意点
网站搭建：康盛旗下网站 & Asp.net 网站搭建

本文链接

利用Attribute扩展MVC的Title和Sitemap

2010-12-05T12:26:00Z

开篇

无论是 Asp.net 还是 MVC 中，想要设置网站的 Title 或者 Sitemap (不用控件)总是很麻烦。

Title 和 Sitemap 都是有关联的，所以有什么办法可以 Write once, run anywhere 呢？

先看一下效果和用法吧～

[效果]

[用法：Controller中]

[用法：View中]

[用法总结]

只要在 Controller 和 Action 上加上 Attribute 就可以设置当前 Controller 的名字和 Action 的名字。

设置 Controller 和 Action 的属性

[NewPath("Demo", Controller = "Home", Action = "Index")]
public class HomeController : Controller
{
[NewPath("首页", Controller = "Home", Action = "Index")]
public ActionResult Index()
{
ViewData["Message"] = "欢迎使用 ASP.NET MVC!";
return View();
}

public ActionResult About()
{
this.SetNewPath("关于", new { Controller = "Home", Action = "About" });
return View();
}
}

这里，我这个网站名是Demo，那我给所有的 Controller 都加上 Demo 这个名称和相关信息即可

然后，有两张页面，分别是“首页”和“关于”

那我只要在 Action 上加上他们的名称和相关信息即可

Q1：是否可以加多个 Attrubute？

A1：可以，而且可以设置 Order 来设置他们的顺序

Q2：我需要，网站名、首页、文章、文章标题这样的路径怎么办？

A2：代码如下，除了可以在 Attrubute 中设置外，还可以在 Action 代码中设置，因为有些信息需要经过处理后才能得到

[NewPath("Demo", Controller = "Home", Action = "Index", Order = 1)]
[NewPath("首页", Controller = "Home", Action = "Index", Order = 2)]
public class HomeController : Controller
{
[NewPath("新闻", Controller = "News", Action = "Index")]
public ActionResult Detail(int? id)
{
this.SetNewPath("新闻标题", new {Controller = "News", Action = "detail", id = id.Value});
return View();
}
}

在View中显示

一般把上图的代码放在 MasterPage 中，因为他们的用法都是调用同一个函数除了上面提供的两个主要函数外，还有一个很自由的函数： <h2><%=Html.GetSitemap() %></h2>
<h2><%=Html.GetWebPath("<a href=\"{1}\">{0}</a>", " / ") %></h2>

这里，只要传入显示模板和分隔符模板，就可以随意地自定义内容了

源代码和例子

下载地址

本文链接

Unobtrusive JavaScript in ASP.NET MVC 3

2010-11-11T04:14:00Z

Unobtrusive JavaScript 是什么？

<div id="test">
<a href="/" onclick="Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, httpMethod: 'GET', updateTargetId: 'test' });">测试</a>
</div>


<div id="test">
<a data-ajax="true" data-ajax-method="GET" data-ajax-mode="replace" data-ajax-update="#test" href="/">测试</a>
</div>

以上的代码分别是 MVC 3 在“关闭”和“开启” Unobtrusive JavaScript 后生成的 Ajax.ActionLink。

那 Unobtrusive JavaScript到底是什么呢？简单地来说，就是一种代码分离的思想，把行为层和表现层分离开。

具体的可以查看维基百科下对Unobtrusive JavaScript的解释。

Unobtrusive JavaScriptin ASP.NET MVC 3

Unobtrusive JavaScript 的好处显而易见，但是如何在MVC3使用Unobtrusive JavaScript呢？

1、引用相应的Javascript文件

这四个文件包含在 MVC 3 的 Scripts 文件夹中，直接引用即可。

值得注意的是：jquery.unobtrusive-ajax.min.js 和 jquery.validate.unobtrusive.min.js 是两个用来让 jquery 支持 Unobtrusive JavaScript 的库。

在 jQuery 官网上看不到，打开后发现，原来是微软自己写的。

另外，以前用来实现 MVC Ajax 和客户端验证的三个文件 MicrosoftAjax, MicrosoftMvcAjax.js, MicrosoftMvcValidation.js 不需要再引用了。

原因就是因为，微软在 MVC 3 使用 jQuery 来实现 Ajax 了，而上面两个 javascript 库就相当于是两个 Adapter（适配器）

2、开启 Unobtrusive JavaScript

MVC3中的Web.Config文件中默认多了两个配置项

这里是一个全局设置，你可以打开或者关闭。

另外，你也可以在任何一个 Action 或 Controller 中执行以下代码，灵活地进行控制，来处理一些特殊的 Action 或 Controller。

HtmlHelper.ClientValidationEnabled = true;
HtmlHelper.UnobtrusiveJavaScriptEnabled = true;

3、如果不需要用 Unobtrusive JavaScript 呢？

如果不需要用的话根据上面的方法关闭即可。

但是要注意一点！这时候，如果你需要用 Ajax 或者客户端验证，务必引用MVC3以前版本中的三个 javascript文件：MicrosoftAjax, MicrosoftMvcAjax.js, MicrosoftMvcValidation.js

否则就不能实现Ajax 和客户端验证了。

Unobtrusive Ajax in ASP.NET MVC 3

原文：《Unobtrusive Ajax in ASP.NET MVC 3》

关于 AjaxOptions

MVC 中 AjaxHelper 的扩展方法，提供了一系列的 Ajax 方法，例如：ActionLink RouteLink, BeginForm, BeginRouteForm 等。它们的使用方法和 HtmlHelper很像，主要的区别就在于 AjaxHelper 有一个 AjaxOptions 参数。

public class AjaxOptions {
public string Confirm { get; set; }
public string HttpMethod { get; set; }
public InsertionMode InsertionMode { get; set; }
public int LoadingElementDuration { get; set; }
public string LoadingElementId { get; set; }
public string OnBegin { get; set; }
public string OnComplete { get; set; }
public string OnFailure { get; set; }
public string OnSuccess { get; set; }
public string UpdateTargetId { get; set; }
public string Url { get; set; }
}

这些属性会告诉 MVC 如何生成你的 Ajax 代码。

传统的生成方式

当 unobtrusive 模式被关闭的时候，MVC 会把代码写在你的 <a> 标签或者 <form> 标签中，并且靠 MicrosoftAjax.js 和 MicrosoftMvcAjax.js 来执行相应的代码。

MVC1 和 MVC2 中就是这样做的。

依赖于 Unobtrusive JavaScript 的生成方式

当 unobtrusive 模式打开的时候，代码彻底的改变了，而且是那么地简洁！

你会发现这些HTML代码是非常容易读懂的。

映射AjaxOptions属性

下表列出了 AjaxOptions 和 HTML 5 的映射关系

AjaxOptions	HTML attribute
Confirm	data-ajax-confirm
HttpMethod	data-ajax-method
InsertionMode	data-ajax-mode *
LoadingElementDuration	data-ajax-loading-duration **
LoadingElementId	data-ajax-loading
OnBegin	data-ajax-begin
OnComplete	data-ajax-complete
OnFailure	data-ajax-failure
OnSuccess	data-ajax-success
UpdateTargetId	data-ajax-update
Url	data-ajax-url

除了这些属性外，还有一个额外的 data-ajax="true" 属性，代表这是一个 Ajax 方法。

* = data-ajax-mode 只有在设置 UpdateTargetId 被设置后才有效。

** = data-ajax-loading-duration 只有在 LoadingElementId 被设置后才有效。

Ajax 回调

传统 Ajax 和 unobtrusive JavaScript 的主要区别就在于 Ajax 的回调。当所有的回调函数都被定义在 Ajax 库中以后，你的代码就会变成这种理想化的风格。

当你在 MVC 3 中使用 unobtrusive Ajax 的时候，四个基本的回调函数会被因设为 jQuery.Ajax 的函数。

OnBegin => “beforeSend”

OnComplete => “complete”

OnFailure => “error”

OnSuccess = > “success”

你可以给他们传递一个函数名，或一段匿名函数作为处理函数。

如果你的处理函数是一个函数名，并且参数列表符合Ajax标准，那么 jQuery.Ajax 便会把值传递给这个函数并执行。

如果是匿名函数的话，过程大同小异。

Ajax 回调函数的参数列表：

xhr : XMLHttpRequest 对象

status : 仅限 OnBegin

error : 仅限 OnFailure

data : 仅限 OnSuccess

Unobtrusive Client Validation in ASP.NET MVC 3

原文：《Unobtrusive Client Validation in ASP.NET MVC 3》

传统的生成方式

一下是 MVC 数据验证框架下对于 Model 的描述（这部分不变）

public class ValidationModel {
[Required]
public string FirstName { get; set; }

[Required, StringLength(60)]
public string LastName { get; set; }

[Range(1, 130)]
public int Age { get; set; }
}

当开启客户端验证后：（具体开启方法和 Unobtrusive Javascript 大同小异，请看第二部分）

<label for="FirstName">FirstName</label>
<input class="text-box single-line" id="FirstName" name="FirstName" type="text" value="" />
<span class="field-validation-valid" id="FirstName_validationMessage"></span>

<label for="LastName">LastName</label>
<input class="text-box single-line" id="LastName" name="LastName" type="text" value="" />
<span class="field-validation-valid" id="LastName_validationMessage"></span>

<label for="Age">Age</label>
<input class="text-box single-line" id="Age" name="Age" type="text" value="" />
<span class="field-validation-valid" id="Age_validationMessage"></span>

<script type="text/javascript">
//<![CDATA[
if (!window.mvcClientValidationMetadata) { window.mvcClientValidationMetadata = []; }
window.mvcClientValidationMetadata.push({"Fields":[{"FieldName":"FirstName","ReplaceValidationMessageContents":true,"ValidationMessageId":"FirstName_validationMessage","ValidationRules":[{"ErrorMessage":"The FirstName field is required.","ValidationParameters":{},"ValidationType":"required"}]},{"FieldName":"LastName","ReplaceValidationMessageContents":true,"ValidationMessageId":"LastName_validationMessage","ValidationRules":[{"ErrorMessage":"The LastName field is required.","ValidationParameters":{},"ValidationType":"required"},{"ErrorMessage":"The field LastName must be a string with a maximum length of 60.","ValidationParameters":{"max":60},"ValidationType":"length"}]},{"FieldName":"Age","ReplaceValidationMessageContents":true,"ValidationMessageId":"Age_validationMessage","ValidationRules":[{"ErrorMessage":"The field Age must be between 1 and 130.","ValidationParameters":{"min":1,"max":130},"ValidationType":"range"},{"ErrorMessage":"The Age field is required.","ValidationParameters":{},"ValidationType":"required"},{"ErrorMessage":"The field Age must be a number.","ValidationParameters":{},"ValidationType":"number"}]}],"FormId":"form0","ReplaceValidationSummary":true,"ValidationSummaryId":"validationSummary"});
//]]>
</script>

当 unobtrusive JavaScript 关闭后，你会看到以上代码（和 MVC 2 中相同）。

你会发现在后面多了一段 Javascript 代码，而这里，便是对表单验证的核心。

依赖于 Unobtrusive JavaScript 的生成方式

开启 Unobtrusive Javascript 后，代码完全改变了

<label for="FirstName">FirstName</label>
<input class="text-box single-line" data-val="true" data-val-required="The FirstName field is required." id="FirstName" name="FirstName" type="text" value="" />
<span class="field-validation-valid" data-valmsg-for="FirstName" data-valmsg-replace="true"></span>

<label for="LastName">LastName</label>
<input class="text-box single-line" data-val="true" data-val-length="The field LastName must be a string with a maximum length of 60." data-val-length-max="60" data-val-required="The LastName field is required." id="LastName" name="LastName" type="text" value="" />
<span class="field-validation-valid" data-valmsg-for="LastName" data-valmsg-replace="true"></span>

<label for="Age">Age</label>
<input class="text-box single-line" data-val="true" data-val-number="The field Age must be a number." data-val-range="The field Age must be between 1 and 130." data-val-range-max="130" data-val-range-min="1" data-val-required="The Age field is required." id="Age" name="Age" type="text" value="" />
<span class="field-validation-valid" data-valmsg-for="Age" data-valmsg-replace="true"></span>

其中最大的改变就是下面的 Javascript 代码消失了，转而变为 HTML 5 的各种属性。

属性是如何生成的

当表单中的一项在后端代码中有数据验证的时候，MVC 会现在它的属性中加上 data-val="true"，并且讲所有规则以 data-val-rulename="message" 的形式，加在属性上。

如果想使用默认的客户端验证信息，你只要把属性值留空，那么客户端验证会自动生成形如 data-val-rulename-paramname="paramvalue" 的属性。

桥接 HTML 和 jQuery ：适配器

写一个客户端验证有两个步骤：1、为 jQuery 验证编写验证规则，2、在 HTML 代码中加上属性，并且使用适配器转换为对应的 jQuery 验证规则。（这个在非 MVC 中也适用）

你可以调用 jQuery.validator.unobtrusive.adapters. 来编写适配规则。

这里有三个方法能帮助你注册三种很常规的适配器。(addBool, addSingleVal, and addMinMax)

具体的方法大家可以看一下原文，因为 jquery.validate.unobtrusive.min.js 已经把这些适配规则都写好了，所以不加以阐述了，如果想了解原理的话可以去看一下~

ENDING

最后，还不太了解 MVC 数据验证的朋友可以看一下我的另一篇文章：

深入浅出 MVC 数据验证 2.0 [附演示源码]

本文链接

Visual Studio下的 JS & CSS 压缩和编辑插件

2010-10-30T22:41:00Z

先声明一下，这个只是我的一个设想，目前还没实现

JS压缩？CSS压缩？

这个大家肯定都听说过，一个成熟的网站，JS压缩和CSS压缩是必须的，也是一个很好的提高网站性能的途径。

但是，压缩好的JS和CSS怎么编辑呢？

好吧，可以用支持JS或者CSS自动格式化的编辑器，让它还原…

然后，编辑好后再压缩…

不觉得很麻烦吗？

Visual Studio 下的解决方案

先看一张图：

这是什么？

一个 .js文件

纳尼？…

它可以像aspx文件一样展开！

还有一个和它关联的文件 .js.source！

是的，按照我的设想，在文件夹中会有2个文件：.js 和 .js.source

然后在VS里编辑的时候，编辑的是 .js.source 文件，每次保存的时候，它会自动压缩一下，放到 .js文件中

在网页中，引用 .js的文件即可~

CSS也可以用同样的方法实现

求合作伙伴

小弟不才，不懂VS插件开发，以上只是一个设想，有哪位朋友愿意合作，我们一起做一个这样的VS插件出来？

另外，想单独做的也和我联系下~毕竟创意也是有知识产权的~到时候引用一下我的博客就行~

本文链接