I’m super excited to announce
the July 2013 release of
the Ajax
Control Toolkit. You can download
the new version of
the Ajax
Control Toolkit from CodePlex (http://ajaxControlToolkit.CodePlex.com) or install
the Ajax
Control Toolkit from NuGet:
With this release, we have completely rewritten
the way
the Ajax
Control Toolkit combines, minifies, gzips, and caches JavaScript files.
The goal of this release was to improve
the performance of
the Ajax
Control Toolkit and make it easier to create custom Ajax
Control Toolkit controls.
Improving Ajax
Control Toolkit Performance
Previous releases of
the Ajax
Control Toolkit optimized performance for a single page but not multiple pages. When you visited each page in an app,
the Ajax
Control Toolkit would combine all of
the JavaScript files required by
the controls in
the page into a new JavaScript file. So, even if every page in your app used
the exact same controls, visitors would need to download a new combined Ajax
Control Toolkit JavaScript file for each page visited.
Downloading new scripts for each page that you visit
does not lead to good performance. In general, you want to make as few requests for JavaScript files as possible and take maximum advantage of caching.
For most apps, you would get much better performance if you could specify all of
the Ajax
Control Toolkit controls that you need for your entire app and create a single JavaScript file which could be used across your entire app. What a great idea!
Introducing
Control Bundles
With this release of
the Ajax
Control Toolkit, we introduce
the concept of
Control Bundles. You define a
Control Bundle to indicate
the set of Ajax
Control Toolkit controls that you want to use in your app.
You define
Control Bundles in a file located in
the root of your application named AjaxControlToolkit.config. For example,
the following AjaxControlToolkit.config file defines two
Control Bundles:
<ajaxControlToolkit>
<controlBundles>
<controlBundle>
<control name="CalendarExtender" />
<control name="ComboBox" />
</controlBundle>
<controlBundle name="CalendarBundle">
<control name="CalendarExtender"></control>
</controlBundle>
</controlBundles>
</ajaxControlToolkit>
The first
Control Bundle in
the file above
does not have a name. When a
Control Bundle
does not have a name then it becomes
the default
Control Bundle for your entire application.
The default
Control Bundle is used by
the ToolkitScriptManager by default. For example,
the default
Control Bundle is used when you declare
the ToolkitScriptManager like this:
<ajaxToolkit:ToolkitScriptManager runat=”server” />
The default
Control Bundle defined in
the file above includes all of
the scripts required for
the CalendarExtender and ComboBox controls. All of
the scripts required for both of these controls are combined, minified, gzipped, and cached automatically.
The AjaxControlToolkit.config file above also defines a second
Control Bundle with
the name CalendarBundle. Here’s how you would use
the CalendarBundle with
the ToolkitScriptManager:
<ajaxToolkit:ToolkitScriptManager runat="server">
<ControlBundles>
<ajaxToolkit:ControlBundle Name="CalendarBundle" />
</ControlBundles>
</ajaxToolkit:ToolkitScriptManager>
In this case, only
the JavaScript files required by
the CalendarExtender
control, and not
the ComboBox, would be downloaded because
the CalendarBundle lists only
the CalendarExtender
control. You can use multiple named
control bundles with
the ToolkitScriptManager and you will get all of
the scripts from both bundles.
Support for ControlBundles is a new feature of
the ToolkitScriptManager that we introduced with this release. We extended
the ToolkitScriptManager to support
the Control Bundles that you can define in
the AjaxControlToolkit.config file.
Let me be explicit about
the rules for
Control Bundles:
1. If you do not create an AjaxControlToolkit.config file then
the ToolkitScriptManager will download all of
the JavaScript files required for all of
the controls in
the Ajax
Control Toolkit. This is
the easy but low performance option.
2. If you create an AjaxControlToolkit.config file and create a ControlBundle without a name then
the ToolkitScriptManager uses that
Control Bundle by default. For example, if you plan to use only
the CalendarExtender and ComboBox controls in your application then you should create a default bundle that lists only these two controls.
3. If you create an AjaxControlToolkit.config file and create one or more named
Control Bundles then you can use these named
Control Bundles with
the ToolkitScriptManager. For example, you might want to use different subsets of
the Ajax
Control Toolkit controls in different sections of your app.
I should also mention that you can use
the AjaxControlToolkit.config file with custom Ajax
Control Toolkit controls – new controls that you write. For example, here is how you would register a set of custom controls from an assembly named MyAssembly:
<ajaxControlToolkit>
<controlBundles>
<controlBundle name="CustomBundle">
<control name="MyAssembly.MyControl1" assembly="MyAssembly" />
<control name="MyAssembly.MyControl2" assembly="MyAssembly" />
</controlBundle>
</ajaxControlToolkit>
What about ASP.NET Bundling and Minification?
The idea of
Control Bundles is similar to
the idea of Script Bundles used in ASP.NET Bundling and Minification. You might be wondering why we didn’t simply use Script Bundles with
the Ajax
Control Toolkit. There were several reasons.
First, ASP.NET Bundling
does not work with scripts embedded in an assembly. Because all of
the scripts used by
the Ajax
Control Toolkit are embedded in
the AjaxControlToolkit.dll assembly, ASP.NET Bundling was not an option.
Second, Web Forms developers typically think at
the level of controls and not at
the level of individual scripts. We believe that it makes more sense for a Web Forms developer to specify
the controls that they need in an app (CalendarExtender, ToggleButton) instead of
the individual scripts that they need in an app (the 15 or so scripts required by
the CalenderExtender).
Finally, ASP.NET Bundling
does not work with older versions of ASP.NET.
The Ajax
Control Toolkit needs to support ASP.NET 3.5, ASP.NET 4.0, and ASP.NET 4.5. Therefore, using ASP.NET Bundling was not an option.
There is nothing wrong with using
Control Bundles and Script Bundles side-by-side.
The ASP.NET 4.0 and 4.5 ToolkitScriptManager supports both approaches to bundling scripts.
Using
the AjaxControlToolkit.CombineScriptsHandler
Browsers cache JavaScript files by URL. For example, if you request
the exact same JavaScript file from two different URLs then
the exact same JavaScript file must be downloaded twice. However, if you request
the same JavaScript file from
the same URL more than once then it only needs to be downloaded once.
With this release of
the Ajax
Control Toolkit, we have introduced a new HTTP Handler named
the AjaxControlToolkit.CombineScriptsHandler. If you register this handler in your web.config file then
the Ajax
Control Toolkit can cache your JavaScript files for up to one year in
the future automatically.
You should register
the handler in two places in your web.config file: in
the <httpHandlers> section and
the <system.webServer> section (don’t forget to register
the handler for
the AjaxFileUpload while you are there!).
<httpHandlers>
<add verb="*" path="AjaxFileUploadHandler.axd"
type="AjaxControlToolkit.AjaxFileUploadHandler, AjaxControlToolkit" />
<add verb="*" path="CombineScriptsHandler.axd"
type="AjaxControlToolkit.CombineScriptsHandler, AjaxControlToolkit" />
</httpHandlers>
<system.webServer>
<validation validateIntegratedModeConfiguration="false" />
<handlers>
<add name="AjaxFileUploadHandler" verb="*" path="AjaxFileUploadHandler.axd"
type="AjaxControlToolkit.AjaxFileUploadHandler, AjaxControlToolkit" />
<add name="CombineScriptsHandler" verb="*" path="CombineScriptsHandler.axd"
type="AjaxControlToolkit.CombineScriptsHandler, AjaxControlToolkit" />
</handlers>
<system.webServer>
The handler is only used in release mode and not in debug mode. You can enable release mode in your web.config file like this:
<compilation debug=”false”>
You also can override
the web.config setting with
the ToolkitScriptManager like this:
<act:ToolkitScriptManager ScriptMode=”Release” runat=”server”/>
In release mode, scripts are combined, minified, gzipped, and cached with a far future cache header automatically.
When
the handler is not registered, scripts are requested from
the page that contains
the ToolkitScriptManager:
When
the handler is registered in
the web.config file, scripts are requested from
the handler:
If you want
the best performance, always register
the handler. That way,
the Ajax
Control Toolkit can cache
the bundled scripts across page requests with a far future cache header. If you don’t register
the handler then a new JavaScript file must be downloaded whenever you travel to a new page.
Dynamic Bundling and Minification
Previous releases of
the Ajax
Control Toolkit used a Visual Studio build task to minify
the JavaScript files used by
the Ajax
Control Toolkit controls.
The disadvantage of this approach to minification is that it made it difficult to create custom Ajax
Control Toolkit controls.
Starting with this release of
the Ajax
Control Toolkit, we support dynamic minification.
The JavaScript files in
the Ajax
Control Toolkit are minified at runtime instead of at build time.
Scripts are minified only when in release mode. You can specify release mode with
the web.config file or with
the ToolkitScriptManager ScriptMode property.
Because of this change,
the Ajax
Control Toolkit now depends on
the Ajax Minifier. You must include a reference to AjaxMin.dll in your Visual Studio project or you cannot take advantage of runtime minification. If you install
the Ajax
Control Toolkit from NuGet then AjaxMin.dll is added to your project as a NuGet dependency automatically. If you download
the Ajax
Control Toolkit from CodePlex then
the AjaxMin.dll is included in
the download.
This change means that you no longer need to do anything special to create a custom Ajax
Control Toolkit. As an open source project, we hope more people will contribute to
the Ajax
Control Toolkit (Yes, I am looking at you.) We have been working hard on making it much easier to create new custom controls. More on this subject with
the next release of
the Ajax
Control Toolkit.
A Single Visual Studio Solution
We also made substantial changes to
the Visual Studio solution and projects used by
the Ajax
Control Toolkit with this release. This change will matter to you only if you need to work directly with
the Ajax
Control Toolkit source code.
In previous releases of
the Ajax
Control Toolkit, we maintained separate solution and project files for ASP.NET 3.5, ASP.NET 4.0, and ASP.NET 4.5. Starting with this release, we now support a single Visual Studio 2012 solution that takes advantage of multi-targeting to build ASP.NET 3.5, ASP.NET 4.0, and ASP.NET 4.5 versions of
the toolkit.
This change means that you need Visual Studio 2012 to open
the Ajax
Control Toolkit project downloaded from CodePlex. For details on how we setup multi-targeting, please see Budi Adiono’s blog post:
http://www.budiadiono.com/2013/07/25/visual-studio-2012-multi-targeting-framework-project/
Summary
You can take advantage of this release of
the Ajax
Control Toolkit to significantly improve
the performance of your website. You need to do two things: 1) You need to create an AjaxControlToolkit.config file which lists
the controls used in your app and 2) You need to register
the AjaxControlToolkit.CombineScriptsHandler in
the web.config file.
We made substantial changes to
the Ajax
Control Toolkit with this release. We think these changes will result in much better performance for multipage apps and make
the process of building custom controls much easier. As always, we look forward to hearing your feedback.
