Shulou(Shulou.com)06/03 Report--

This article mainly introduces the ASP.NET component System.Web.Optimization operating principle of the example analysis, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let Xiaobian take you to understand.

1] introduction at the beginning

I will briefly analyze the operation principle and basic cache problems of the ASP.NET component System.Web.Optimization that is bundled with static files:

There are a lot of static files in our project. In order to pursue modularization and plug-in, many static files are designed as modules or decomposed, and are used on the UI layer in a combined way when needed. This brings a problem. Too many files will affect the speed at which the browser loads pages, and due to the concurrency restrictions of the browser, parallel requests are not unlimited, so the function of bundling static files is generated. In fact, in the past, before IIS integrated the pipeline model, we could only output through dynamic resources, that is, we often saw a lot of requests ending with * .axd on * aspx pages, of course, most of the cases were used with ASP.NETAJAX to output dynamic JS, HTMDOM, and CSS.

The latest IIS has been well integrated with the ASP.NET pipeline model, that is, we can control all requests through IIS, including static files, through the extension of ASP.NET itself, so it is possible to bundle static files.

Next, we will analyze the basic operation principle of the System.Web.Optimization component, how it is loaded dynamically and how to control the cache.

2] System.Web.Optimization components

Whenever we create a new ASP.NETMVC4 site, there will be a BundleConfig.cs startup file in the ~ / App_Start directory. Of course, other ASP.NET4.0 and above projects will also have

It really puzzled me when I saw this file for the first time, so I'm going to analyze it briefly and know the basic principles.

The code is a static method, and then pass in a BundleCollection collection object, which is actually a collection of Bundle objects, and then by registering multiple Bundle; and each Bundle corresponding to multiple static files inside the collection, you can imagine that the achievement is a collection of key-value pairs; the later Include method contains N multiple static files, where the static file path can be a string that conforms to specific rules, which can be calculated internally.

This is the registration phase, and then there is the usage phase, which is very simple as long as we can directly reference the list of static files through the Key string we registered.

We only need to focus on the Styles.Render and Scripts.Render methods, which are a list of static files configured in the background before page injection; so what we see on the client side is the collection of bundled files.

The connection address of the file is already the bundled address. This address is the key we used when we registered before, and then it needs this key to get the value static file list. For your bundling to work, you need to add a paragraph when registering: BundleTable.EnableOptimizations = true; code, which means to enable bundling. If bundling is not enabled, it will have no effect by default in the debug environment, because System.Web.Optimization uses the default bundling policy. If it is in Debug mode, bundling will not be enabled. If you artificially set it, the default setting will be overridden.

That's all we need to use. Now we need to understand how it works and how it works.

3] basic principles of System.Web.Optimization components

Now that IIS integrates the pipeline model, we must be able to find the corresponding HttpModule. In order to save time, I won't download the source code. Let's take a look at it with the decompiler tool.

This is Bundle's HttpModule, which is only used to process

The connection address of Bundle, although it is in the pipeline of HTTP; it is easy to find it, but the strange thing is that I did not find its configuration information in Web.config. It is strange that it still goes to the system file to change, of course it is impossible. So for the moment, I can't think of any way to register dynamically. When it comes to dynamic registration, I suddenly have an idea. It seems that there is an Assembly-level feature used to register the pre-code at Application_Start startup, which will be executed before Application starts. Let's take a look.

Sure enough, it's hidden here. It registers a PreApplicationStartCode static class and starts it using the Start method.

This code is very simple, first determine whether the registration has been performed, if not, perform dynamic registration, this dynamic registration component is included in the .NET Framework, in Microsoft.Web.Infrastructure only belongs to the platform-related, not directly related to ASP.NET, we can use Microsoft.Web.Infrastructure to develop our own WEB components There is a question here: why should static methods be judged? they will only be executed once, because the execution of static methods is not controlled, so if they are not judged, they are likely to be registered many times.

Now basically we have found the source. Let's put it here on the server side. There are a lot of questions about the client. Since it has bundled us, how does the cache handle? that is to say, is its output cache set? if it is set, there is no problem.

[client cache related]

To get a good understanding of the information between requests, let's use Fiddler to monitor

We see that the Cache part of it uses If-Modified-Since to represent the last modification of the local file, so that the server can verify whether the file has changed. If the response status code of the server is not changed, it means that Bundle does not set up client-side mandatory caching of this file when it is output. We can also see it through the Pragma: no-cache header.

So we come to the conclusion that all the files from Bundle cannot be cached directly in the browser, and every time we bring the Cache segment If-Modified-Since to verify the file version of the server; just here we can match the parameters after the static file address of the dynamic output.

For example:

/ Content/css?v=ZPnWVRT3c0yyrVDPmI-xkJuhBdJfQsL3A0K5C9WTOk01

The v parameter after this link indicates the current version of the virtual file after Bundle. If we modify the file on the server, then the If-Modified-Since verification of this file will fail and a new version number will be generated as the connection parameter. Let's take a look and feel at ease.

I added a style of width:auto, so at this time I refresh the client and there should be no more 304.

Obviously the version of the / Content/css?v=doYFOk3BdOYWDIRbQ7juV6eQdlJAu6RtC0G13El7X041 file has changed, so the Response should not be 304.

If the version number of the static file is changed, If-Modified-Since will not be taken at all. This is used for Post verification each time. In fact, it means that the file name of the static file can only be changed if the file is bundled without the IIS integration mode.

4] extend the custom type static file

The Bundle object is the base class for all files that need to be bundled. If we need to extend some static files, such as some domain-specific static files, we can inherit this class directly.

[cache of XML files]

Extending the XML file is very simple. We only need to inherit the Bundle object. All about dynamic generation of URL has special object handling. Let's take a look at the code.

Public class XmlBundle: Bundle {public XmlBundle (string path): base (path) {} public static class XmlBundleRender {public static IHtmlString Render (string path) {BundleResolver bundle = new BundleResolver (BundleTable.Bundles); return new HtmlString (string.Format (@ ", bundle.GetBundleUrl (path);}}

First we need a XmlBundle inherited from the Bundle object to represent all the bundled containers of our XML files to be transferred, and then we need a static method to register the bundled URL

The generation of this URL is accomplished by a special BundleResolver object. We only need to pass in all the BundleCollection objects. I have written a link of type stylesheet here in order to test it in the browser. So we can use it directly where we need it, and I quote: @ MvcApplication4.Seed.XmlBundleRender.Render ("~ / custom/xml") in the index view; isn't it easy so that we can bundle all the files we want to control the binding, with inheritance plus simple static method assistance?

Let's see if our XML file has all the caching features.

The first request does not add an If-Modified-Since segment, and the returned content is a simple 222test. Now let's see if it will use the cache next time without changing the content.

As we expected, using cached data, we need to modify the XML file on the server and change it from 222to 243454637 to see if the local cache is automatically flushed, that is, it will not return status.

It also refreshes the cache, which is in line with the theory, and correctly returns our modified value.

Thank you for reading this article carefully. I hope the article "sample Analysis of the Operation principle of ASP.NET components System.Web.Optimization" shared by the editor will be helpful to you. At the same time, I also hope that you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.