Microsoft ASP.NET SignalR: The Real-Time Web Made Simple

Session Abstract : 

SignalR is one of the latest components of the ASP.NET runtime, but it can do a lot more than just web. Come learn how you can build a real-time web application with minimal heavy lifting, without needing to learn another large framework. Then, take those lessons and use nearly identical syntax to give Modern Apps, Windows Azure Worker Roles running in the cloud, and other types of applications real-time HTTP functionality. The SignalR abstraction is a shift in how you think about web programming and in what's possible across a multitude of platforms and environments, and this session gets you started quickly with simple demonstrations that walk you through all the major capabilities of the #1 most followed open-source C# project on GitHub that grew to become the latest trick in the ASP.NET developer tool chest.

Session Link : https://www.devconnections.com/dev13/public/SessionDetails.aspx?FromPage=SpeakerList.aspx&SessionID=1008785&SortMenu=102006

Slide Deck: https://www.slideshare.net/rustd/microsoft-signal-r

ASP.NET Identity & Security

Session Abstract : ASP.NET Identity is a new look at the existing ASP.NET membership system. ASP.NET Identity makes it easier to integrate different authentication systems such as local username, password as well as social logins such as Facebook, Twitter etc. It also gives you greater control over persisting data to your backend technology of choice. We will also look at the improvements in VS tooling that let you easily create application that allow users from Windows Azure Active Directory to sign in.

Session Link: https://www.devconnections.com/dev13/public/SessionDetails.aspx?FromPage=SpeakerList.aspx&SessionID=1008786&SortMenu=102006

Slide Deck: https://www.slideshare.net/rustd/microsoft-aspnet-identity-security  

I hope you enjoyed the talks and build something fun!!!

I do plan to regularly update this post and add more tools/software as I find more useful ones.

• https://office.microsoft.com/en-us/onenote/
• https://www.microsoft.com/web/downloads/platform.aspx
• https://windows.microsoft.com/en-US/windows7/products/features/snipping-tool
• https://www.microsoft.com/en-us/server-cloud/windows-server/server-virtualization.aspx

Please find the slides and the samples as follows

Slides

Samples

I have also included my talk walkthrough so you can relate to all the concepts I talked about

Talk Walkthrough

- Outline
     -- Not the usual flow of features but some interesting things you can do with the webforms framework
     -- Pattern based development
     -- Cleaner code
     -- Extensibility    

- Templates rendering
    -- Standards compliant

- OAuth/Open Id Login
     -- Uncomment AuthConfig
     -- Login using Google

- Web Optimization
     -- Debug=true(all files)
    -- Debug=false(bundled files)
     -- Framework scripts
         ---- Bundled as nuget packages
- Tips & tricks
     -- Script Manager
         --- Remappings
             ---- Originally come from aspnet ajaxcdn but you can change it
         -- CDN support(enable cdn=true)
             ---- Even the bundles
         -- LoadSuccessExpression
             ---- If the network goes out then you can load the scripts locally

- Patterns/Tips & Tricks
     -- Model Binding
         ---- Basics
        ---- Model Binding
        ---- Routing
        ---- PRG
         ---- Repository
         ---- Unit Testability
         ---- Dynamic data
         ---- Model Binding Extensibility
         ------  Aggregate Value Providers and an attribute
                 Similar to mvc
          ----- AdHoc Model Binding
                 No data controls
                 Anonymous types cannot be constructed

    - Control Builder Interceptor
         -- Customize the compilation system
         -- Change what kind of code gets generated
         -- Great of custom control developers
         -- Edit the codedom of the existing control - not possible before
             ---- Sub class the control
             ---- Reimplement the control builder
         -- To use this put it in the config
         -- Layer of indirection between UI/code something like MVP. Little code talking to UI
         -- Layer of indirection between code and markup
         -- Take this idea further along
             ---- Advanced control builder interceptor
             ---- Earlier written using custom controls but with the new feature in v4.5 you can do it more easily

     -- Command Bubbling
         ---- WPF/Silverlight
         ---- Rather than event handlers to do business logic - command interface
         ---- Remove as much code as I can
          ---- Code interacts with controls - separation of concerns
          ---- Declarative statements to wire up server controls to data
          ---- Imperative logic factored out into different classes
        ---- Webforms has bubbling event(

Controls like gridview work like this)
         ---- Separation of concern/Clean code behind
         ---- Event bubbling to update UI when an event happens(click/button)
         ---- Component driven/event driven

--  Tag Mapping
         -- Code to modify control…do not put it in the code behind
         -- Remapping controls
     -- Custom Templates
         -- User voice item
         -- Load them from database/file etc

  -- Imperative vs declarative
             -- Declarative - more maintainable - you know everything statically
             -- Imperative - set stuff dynamically
   
- Async Support
     -- Async=false
     -- Async=true
    --Async/await usage
       

- FriendlyURLs
     -- Cleaner Urls which are easy to use
     -- Show the async demo on a mobile device

- Scaffolding
     -- Person class
     -- Scaffold using UI
     -- CRUD on desktop
     -- Default on mobile

Data Binding with Model Binding

Uptil ASP.NET v4.0, data binding in controls happened with data bound controls such as GridView used to bound to data source controls such as ObjectDataSource. We will use this as a reference to understand the flow in the Model Binding System. A lot of the implementation derives inspiration from ObjectDataSource.

Following snippet shows how a GridView calls the Model Binding system to get a list of products.

 <asp:GridView ID="getProduct" runat="server" ItemType="Products"

            UpdateMethod="getProduct_UpdateItem"

             SelectMethod="getProduct_GetData" />

public IQueryable<Products> getProduct_GetData()

        {

            return _context.Products.ToList();

        }

        // The id parameter name should match the DataKeyNames value set on the control

        public void getProduct_UpdateItem(int id)

        {

            Products item = null;            

            TryUpdateModel(item);

            if (ModelState.IsValid)

            {

                // Save changes here, e.g. MyDataLayer.SaveChanges();

            }

        }

At the heart of the Model Binding system is a datasource called ModelDataSource. and ModelDataSourceView As a developer when you never Bind the GridView to the ModelDataSource. The DataSource is an implementation detail which takes in value from the control and passes onto the ModelBinding system to perform the Binding & Validation to the model and gives the result back to the control/page.

Page Execution Flow

Now that we know that there is a datasource involved at the implementation level of the ModelBinding system, let’s look at the flow from the control – ModelBinding – control. At a very high level this is what happens

• GridView calls the SelectMethod to get the values
• This initializes the ModelDataSource and it calls the ExecuteSelect method on ModelDataSourceView
• The ModelDataSourceView calls the DefaultModelBinder
• DefaultModelBinder looks through all the ModelBinderProviders registered in the system and tried to get the ModelBinder that can provide the value for a given Type
• The selected ModelBinder gets called to perform the Binding of values to the Model
• The ModelBinder calls the ValueProvider to get the value.
• This is useful if you want to specify that the value is coming from a control/querystring or other collections

I wanted to put this information out now so that you can get an idea about the plugability areas that exist in the ModelBinding system. In the later posts w We are going to look more into the details

Model Binders and Model Binder Providers

The initialization of the ModelBindig system registers the following ModelBinders. These  partition the responsibilities of the original DefaultModelBinder, making it easy to consume them from your own custom binder or to replace their individual responsibilities. For example, changing how dictionaries are bound application-wide now involves replacing a single provider rather than rewriting the DefaultModelBinder. The binders included in-box are, in order:

· TypeMatchModelBinderProvider – If the incoming value is already typed correctly for the target model (e.g. incoming value is string, property to bind is string), short-circuits the entire process and just returns the string.

· BinaryDataModelBinderProvider – Handles binding base-64 encoded input to byte[] and System.Linq.Data.Binary models.

· KeyValuePairModelBinderProvider – Handles KeyValuePair<TKey, TValue>. Consumed by the dictionary binder.

· ComplexModelDtoModelBinderProvider – Handles complex models. Consumed by the mutable object binder. More info on this type in the tutorial at the end of this document.

· ArrayModelBinderProvider – Handles T[].

· DictionaryModelBinderProvider – Handles IDictionary<TKey, TValue>.

· CollectionModelBinderProvider – Handles IEnumerable<T>.

· TypeConverterModelBinderProvider – Handles simple type conversions, e.g. incoming value is a string and property to bind is an integer.

Value Providers

Following are the Value providers which you can use to specify where should the ModelBinding look for when trying to get the value

In the next few posts we will look at how to do basic create/replace/delete/filtering cases and then look at extending the ModelBinding system using these concepts

Hope you will find this useful!!!

This has been cross posted to https://blogs.msdn.com/b/webdev/archive/2012/11/30/model-binding-fundamentals.aspx

Changes in VS2012

• VS2012 ships with SQL2012 engine.
• VS2012 ships with an enchanced Sql tools(SSDT) which brings in functionality from SSMS(SqlServerManagementStudio) to VS
  • As part of this integration, you will see a new window called “SQL Server Object Browser”. In this window you can do advanced Database management stuff, such as running sprocs, managing Initial Catalogs etc. which were not possible in “Database Explorer”
  • Some videos to learn more about SSDT.
• "Sql Server Express" is no longer installed with VS. Instead VS ships with "Sql Server Express LocalDB".
  • LocalDB development is supported in VS2012 for .NET v4.0/v4.5 on Windows 8/ Windows 7 – Client and Server SKUs
  • LocalDB development is supported in VS2012 for .NET v3.5 on Windows 8 only(Client and Server SKUs)
• Enhanced User experience while upgrading projects from VS2010 to VS2012
  • This user experience has some guidance which help you upgrade databases which were using SQLExpress to LocalDB
• Auto loading of ConnectionStrings in ServerExplorer
  • if we detect that your ConnectionString points to a database which exists, then we load the connectionstring in the ServerExplorer so its there when you want to use it. This is an improvement from Dev10 where you had to explicitly add the ConnectionString

Why LocalDB?

The quick pitch for LocalDB is the following: “It is very easy to install and it requires no management” LocalDB runs as your account and not as a system wide service(which is how SqlExpress runs). This post from the SQL team goes in detail about the benefits

With all the changes of moving away from SqlExpress to LocalDB, nothing should change in terms of your application development. You should be able to use  almost the same connectionStrings as you had with SqlExpress, but instead change the DataSource from “.\SQLExpress” to “(LocalDb)\v11.0” and remove the UserInstance flag since LocalDb always runs as your account

Initial Catalog vs AttachDbFileName

If you look at the connectionstring, the templates for ASP.NET WebForms, MVC use in VS 2012, you will notice that the connectionstring looks like follows. This connection is somewhat different to what you might have seen with web projects in VS2010 where we were only using AttachDbFileName.This change has nothing to do with LocalDb, on the contrary this exposes some of the common patterns that have existed when working with SQL.

Following is how these two values are used

Initial Catalog: This entry is a key in the SQL master table which holds all of the databases which were created on an instance. In this case the instance is “(LocalDb)\v11.0”

AttachDbFileName: This entry tells SQL the location of the mdf file which holds the database information.

The SQL engine uses Initial Catalog to look up the database entry in its master list and load the database file from the path specified by AttachDbFileName

One small caveat

By surfacing this information to the developer, a developer can run into the following situation. Let’s say that you ran your application and created a database with the above connectionstring. In this case, if you delete the database file(mdf) from disk and do not change the connectionstring, then SQL will look up the database by the Initial Catalog entry which still exists and will try to load the database from disk based on the AttachDbFileName and since the database does not exist, you will get the following error.

“Cannot attach the file 'c:\users\foo\documents\visual studio 2012\Projects\MvcApplication18\MvcApplication18\App_Data\aspnet-MvcApplication18-20121022222325.mdf' as database 'aspnet-MvcApplication18-20121022222325'.”

To workaround this error do either of the following

• Change the Initial Catalog and AttachDbFileName value to be something unique
• Using SSDT, connect to “(LocalDb)\v11.0” instance and delete the Initial Catalog entry specified in the database

The reason the AttachDbFileName entry exists so that the database file gets dropped in App_Data folder of your application.

How to Videos for basic operations in VS tooling

Cheat sheet of things to remember/do for Data in VS2012

These cheat sheet is useful when you are trying to figure out what instance to use for LocalDB

• Default Instance of Localdb in VS2012 is "(LocalDb)\v11.0"
  • This means whenever you are connecting to a localdb instance you need to type in the above to connect to using Windows Authentication to operate on your database
• Tools-Options is "(LocalDb)\v11.0"
  • This means that any local database that you create will be created using "(LocalDb)\v11.0" instance
  • If you have SqlExpress installed and you want to use SqlExpress as the default local database server you should change this option in VS. This is a global setting for VS
• LocalDB does not run with UserInstance=true setting
  • You will get an error when you run your application

Helpful links/scripts 

• Figuring out the version of your database file
• Common commands to manage a SQL instance

I hope this would help you understand the changes in the Data Tooling experience for VS2012. This was cross posted at https://blogs.msdn.com/b/webdev/archive/2012/11/12/interacting-with-databases-for-web-developers-in-vs-2012.aspx

You can download the samples from

The slide deck is as follows

To solve this problem, I created a Visual Studio Extension which will install the templates that we shipped with VS2012.

Note: This Extension is by no means supported by Microsoft. It is something I created in my own spare time to make it easier for WebForms developers using VS2010SP1 to use the updated templates that we shipped with VS2012

Download and Use the Extension

• If you are using VS2010SP1, then you can do the following else you can download the extension(ASPNETWebForms) from the VS Gallery
• Open VS2010SP1
• Click Tools – Extension Manager
• Goto Online Gallery and search for “aspnet webforms”
• Alternately, you can search for the name of the extensions “ASPNETWebForms”
• Once you have searched for the extension, it will appear as follows in the search result

• Download the extension/ The templates will show up in the File-New project dialog in the following category(Visual C#– Web)
• To use the installed templates, create the project in “File – New Project – Visual C#-Web – ASPNETWebFormsApplication”

• Once the project is created, follow the instructions in the readme.txt file to Build & Run the project

https://visualstudiogallery.msdn.microsoft.com/ec79e369-51bd-4212-83d0-71349d038461 has more details about the Extension and also what SKUs are supported.

Please do give feedback on the VS Gallery for the extension.

This post has been cross posted at https://blogs.msdn.com/b/webdev/archive/2012/10/29/asp-net-web-forms-application-2012-templates-on-visual-studio-2010.aspx 

List the sys admins on a instance

select [name] from sys.syslogins where sysadmin=1

Add yourself/someone as a sysadmin on sql instance

EXEC master..sp_addsrvrolemember @loginame = N'redmond\pranavra', @rolename = N'sysadmin'

EXEC master..sp_addsrvrolemember @loginame = N'BUILTIN\Administrators', @rolename = N'sysadmin'

EXEC master..sp_addsrvrolemember @loginame = N'REDMOND\aapfte', @rolename = N'sysadmin'

Remove yourself/someone as a sysadmin on sql instance

EXEC sp_droprolemember 'sysadmin', 'redmond\pranavra'

Running these commands if you do not have VS Pro and cannot connect to TSqlEditor

• Open an admin prompt
• Goto SQLInstall\Microsoft SQL Server\MSSQL.X\MSSQL\Binn eg D:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\Binn
• sqlcmd -SComputerName\InstanceName Eg Sqlcmd -S .\SQLEXPRESS
• Execute the command as you need eg
  • select [name] from sys.syslogins where sysadmin=1
  • Go

Changing compatibility version of sqldatabase

EXEC sp_dbcmptlevel 'aspnet-WebApplication3-20120502172054', 90

What is Model Binding

Model Binding is a system which binds a value submitted from the client to a model on the server so that the model is available for inspection for validation rules and processing on the server. In essence the system has two fundamental functions – Binding & Validation.

In a WebForms application, data binding(from client to server and vice versa) typically happens via Data Bound and Data Source controls. While this approach has the advantages of an experience where you can get your application up and running easily, it does have some drawbacks for some developers who want to tap in more modern ways of developing applications, such as : doing validation using Data Annotations, PRG pattern, Repository patters, cleaner page code behind etc.

History Behind Model Binding

Model Binding as a system has existed in many Frameworks. Rails implements the core functions of Binding & Validation in its own way. ASP.NET MVC had Model binding support since its early stages. When ASP.NET MVC2 was released, the team released a prototype of an “Extensible Model Binding system”. This prototype made it possible for a  Framework developer to write their own Model Binding system, should they choose to do so.(of course anyone in their right minds would not attempt it, but the ASP.NET team decided anyways to do this for WebForms)

Infact this Extensible Model Binding was how the team derived lots of inspiration from while trying to implement a Model Binding System that integrates the flexibility of Model Binding system and power of controls. ASP.NET WebAPI also derives some inspiration from this extensible model when ASP.NET WebAPI added support for binding using different formatters.

Benefits of Model Binding

With the introduction of Model Binding, it is now much easier to build modern webforms applications. Following are the areas where this integration adds value

• Rich controls support
• All the existing data bound controls such as GridView, ListView etc have been updated to work with Model Binding so you should be able to reuse the rich functionality of these controls
• Validation
• Modern ways of validation using Data Annotation attributes
• Easier to propagate validation errors from Business Layer back to the UI on the page
• Easier to integrate model level validation errors(from ORM such as EF or anything of your choice) when saving the record in the database
• Dynamic Data support
• Easier to add validation via Data Annotations and client side validation
• Easier to customize the UI for columns using Data Annotations and Field Templates
• Add rich UI for integrating jquery based DateTime picker for DateTime fields
• Easier to customize the entities using Data Annotations and Entity Templates
• Easier to embrace the following patterns
• Unit Testing the application layer
• PRG pattern
• Repository pattern
• Cleaner page code behind methods. These server side code files do not have any application functional code and they only focus on UI interactions
• Extensible Model Binding system
• Support scenarios of binding in advanced scenarios such as complex types, ad-hoc Model Binding
• Customize the existing implementation to enable more commonly used scenarios easier such as Master Details view
• Add more Binders and Value providers 

I hope so far this would help you understand the bigger picture with WebForms Model Binding and value it brings to an application developer. As Scott Hanselman noted, this integration also brings ASP.NET MVC/WebForms application development much closer.

In the next post we will be looking at some high level fundamentals and features on Model Binding in WebForms

Cross posted to https://blogs.msdn.com/b/webdev/archive/2012/11/15/asp-net-webforms-model-binding-overview.aspx  

Easy Integration with JQuery and JQueryUI

The default templates for WebForms ship with the following packages “AspNet.ScriptManager.jQuery” and “AspNet.ScriptManager.jQuery.UI.Combined”. These packages make it easier to bring in jquery and jqueryUI libraries  and also register them with the ScriptManager. Here is how it works.

These packages add the following ScriptMappings for jquery and jqueryUI in the PreApplicationStart method of the application

JQuery

string str = "1.7.1";

    ScriptManager.ScriptResourceMapping.AddDefinition("jquery", new ScriptResourceDefinition

    {

        Path = "~/Scripts/jquery-" + str + ".min.js", 

        DebugPath = "~/Scripts/jquery-" + str + ".js", 

        CdnPath = "https://ajax.aspnetcdn.com/ajax/jQuery/jquery-" + str + ".min.js", 

        CdnDebugPath = "https://ajax.aspnetcdn.com/ajax/jQuery/jquery-" + str + ".js", 

        CdnSupportsSecureConnection = true, 

        LoadSuccessExpression = "window.jQuery"

    });

JQuery.UI

string str = "1.8.20";

    ScriptManager.ScriptResourceMapping.AddDefinition("jquery.ui.combined", new ScriptResourceDefinition

    {

        Path = "~/Scripts/jquery-ui-" + str + ".min.js", 

        DebugPath = "~/Scripts/jquery-ui-" + str + ".js", 

        CdnPath = "https://ajax.aspnetcdn.com/ajax/jquery.ui/" + str + "/jquery-ui.min.js", 

        CdnDebugPath = "https://ajax.aspnetcdn.com/ajax/jquery.ui/" + str + "/jquery-ui.js", 

        CdnSupportsSecureConnection = true

    });

These SciptMappings are registered with ScriptManager as follows

<asp:ScriptManager runat="server">

        <Scripts>

            <asp:ScriptReference Name="jquery" />

            <asp:ScriptReference Name="jquery.ui.combined" />            

        </Scripts>

    </asp:ScriptManager>

Now you can enjoy all the benefits of having ScriptManager such as

Debug/Release Support

If you are debugging your application(debug=true) in web.config then ScriptManager will serve the scripts from debug path(non minified scripts) such as “~/Scripts/jquery-1.7.1.js”

CDN Support

If your set EnableCDN=true on the ScriptManager control, then all the Scripts will be served from the CDN path such as “https://ajax.aspnetcdn.com/ajax/jquery-1.7.1.js”

Override Script Mappings

Let’s assume that you wanted to override the scriptmappings to change the CDN path where these scripts are served from. You can do so by changing the scriptmapping before the page is accessed. Typically doing this in Global.asax is better

string str = "1.7.1";

    ScriptManager.ScriptResourceMapping.AddDefinition("jquery", new ScriptResourceDefinition

    {

        Path = "~/Scripts/jquery-" + str + ".min.js", 

        DebugPath = "~/Scripts/jquery-" + str + ".js", 

        CdnPath = "https://https://code.jquery.com/jquery-"+ str + ".min.js", 

        CdnDebugPath = "https://code.jquery.com/jquery-"+ str + ".js", 

        CdnSupportsSecureConnection = true

    });

Updating Jquery/JqueryUI libraries

Let’s say a new version of Jquery or JqueryUI comes along. Traditionally you would have to download the jquery packages for these libraries and then update the script references everywhere on your pages. With the above integration of AspNet.ScriptManager.Jquery packges this scenario really becomes easy since when you update Jquery/JqueryUI you will get corresponding versions of AspNet.ScriptManager.Jquery/AspNet.ScriptManager.Jquery.UI which will update the scriptmappings to the current version of jquery that was downloaded and you do not have to change anything in your application

LoadSuccessExpression

This is a new property which is added to the ScriptMapping and it takes care of the following use case. Imagine that you are serving your scripts from a CDN path and if there is an outage in the CDN, your site will be affected because you will not be able to serve any scripts. This property takes in an expression which evaluates whether the script was loaded correctly and if it fails then it renders the script from the local application path.

Following is how the script tag looks like for jquery(assuming that you are serving scripts from CDN)

<script src="https://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.1.js" type="text/javascript"></script>

<script type="text/javascript">

//<![CDATA[

(window.jQuery)||document.write('<script type="text/javascript" src="Scripts/jquery-1.8.1.js"><\/script>');//]]>

</script>

Remapping Framework scripts

One neat improvement that happened in ASP.NET 4.5 is the decoupling of the “Microsoft Ajax script files(MicrosoftAjaxCore etc)” and the WebForms scripts(GridView.js etc). We did the work in this release so you can serve these scripts from your application Scripts folder rather than load then up from System.Web This makes the scripts easily redistributable and updateable. The following section explains on how you can use these scripts and combine them with WebOptimization feature

Serving Framework Scripts from inside the application

We created the following 2 packages “Microsoft.AspNet.ScriptManager.MSAjax” “Microsoft.AspNet.ScriptManager.WebForms” which do the following

Install the Scripts into your application so it looks like follows

These packages also create the following scriptmappings so that they can be registered with ScriptManager as follows

MicrosoftAjax scripts

We are registering all the scripts and we are bundling them together as “MsAjaxBundle”

ScriptManager.ScriptResourceMapping.AddDefinition("MsAjaxBundle", new ScriptResourceDefinition

    {

        Path = "~/bundles/MsAjaxJs", 

        CdnPath = "https://ajax.aspnetcdn.com/ajax/4.5/6/MsAjaxBundle.js", 

        LoadSuccessExpression = "window.Sys", 

        CdnSupportsSecureConnection = true

    });

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjax.js", "window.Sys && Sys._Application && Sys.Observer");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxCore.js", "window.Type && Sys.Observer");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxGlobalization.js", "window.Sys && Sys.CultureInfo");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxSerialization.js", "window.Sys && Sys.Serialization");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxComponentModel.js", "window.Sys && Sys.CommandEventArgs");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxNetwork.js", "window.Sys && Sys.Net && Sys.Net.WebRequestExecutor");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxHistory.js", "window.Sys && Sys.HistoryEventArgs");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxWebServices.js", "window.Sys && Sys.Net && Sys.Net.WebServiceProxy");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxTimer.js", "window.Sys && Sys.UI && Sys.UI._Timer");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxWebForms.js", "window.Sys && Sys.WebForms");

    PreApplicationStartCode.AddMsAjaxMapping("MicrosoftAjaxApplicationServices.js", "window.Sys && Sys.Services");

Here is the Bundle definition for these scripts

bundles.Add(new ScriptBundle("~/bundles/MsAjaxJs").Include(

                "~/Scripts/WebForms/MsAjax/MicrosoftAjax.js",

                "~/Scripts/WebForms/MsAjax/MicrosoftAjaxApplicationServices.js",

                "~/Scripts/WebForms/MsAjax/MicrosoftAjaxTimer.js",

                "~/Scripts/WebForms/MsAjax/MicrosoftAjaxWebForms.js"));

Here is the ScriptManger registration for these scripts

<asp:ScriptManager runat="server" >

        <Scripts>

            <%--Framework Scripts--%>

            <asp:ScriptReference Name="MsAjaxBundle" />

            <%--Site Scripts--%>

        </Scripts>

    </asp:ScriptManager>

WebForms scripts

We are registering all the scripts and we are bundling them together as “WebFormsBundle”

ScriptManager.ScriptResourceMapping.AddDefinition("WebFormsBundle", new ScriptResourceDefinition

    {

        Path = "~/bundles/WebFormsJs", 

        CdnPath = "https://ajax.aspnetcdn.com/ajax/4.5/6/WebFormsBundle.js", 

        LoadSuccessExpression = "window.WebForm_PostBackOptions", 

        CdnSupportsSecureConnection = true

    });

Bundle Definition

bundles.Add(new ScriptBundle("~/bundles/WebFormsJs").Include(

                  "~/Scripts/WebForms/WebForms.js",

                  "~/Scripts/WebForms/WebUIValidation.js",

                  "~/Scripts/WebForms/MenuStandards.js",

                  "~/Scripts/WebForms/Focus.js",

                  "~/Scripts/WebForms/GridView.js",

                  "~/Scripts/WebForms/DetailsView.js",

                  "~/Scripts/WebForms/TreeView.js",

                  "~/Scripts/WebForms/WebParts.js"));

ScriptManager registration

The reason we have the Assembly and the Path attribute here is because ScriptManager special cases these scripts when it tries to load them, so we had to make some special arrangements with ScriptManager code to make this work This is a process which is called deduping. Basically when the ScriptManager tried to load up these scripts, it can load them up from System.Web or the path attribute and eventually in this case, the ScriptManager dedupes the script references and serves the scripts from the path attribute. This is part of the “special arrangement” that we did in ScriptManager. We were very cautious when doing this given this code path was on a very critical path for mainline ScriptManager scenarios which we did not want to regress.

<asp:ScriptManager runat="server" >

        <Scripts>

            <%--Framework Scripts--%>

            <asp:ScriptReference Name="WebForms.js" Assembly="System.Web" Path="~/Scripts/WebForms/WebForms.js" />

            <asp:ScriptReference Name="WebUIValidation.js" Assembly="System.Web" Path="~/Scripts/WebForms/WebUIValidation.js" />

            <asp:ScriptReference Name="MenuStandards.js" Assembly="System.Web" Path="~/Scripts/WebForms/MenuStandards.js" />

            <asp:ScriptReference Name="GridView.js" Assembly="System.Web" Path="~/Scripts/WebForms/GridView.js" />

            <asp:ScriptReference Name="DetailsView.js" Assembly="System.Web" Path="~/Scripts/WebForms/DetailsView.js" />

            <asp:ScriptReference Name="TreeView.js" Assembly="System.Web" Path="~/Scripts/WebForms/TreeView.js" />

            <asp:ScriptReference Name="WebParts.js" Assembly="System.Web" Path="~/Scripts/WebForms/WebParts.js" />

            <asp:ScriptReference Name="Focus.js" Assembly="System.Web" Path="~/Scripts/WebForms/Focus.js" />

            <asp:ScriptReference Name="WebFormsBundle" />

            <%--Site Scripts--%>

        </Scripts>

    </asp:ScriptManager>

When you run this page you will get script references as follows

<script src="/bundles/MsAjaxJs?v=J4joXQqg80Lks57qbGfUAfRLic3bXKGafmR6wE4CFtc1" type="text/javascript"></script>

<script src="/bundles/WebFormsJs?v=q9E9g87bUDaS624mcBuZsBaM8xn2E5zd-f4FCdIk2cA1" type="text/javascript"></script>

    <script type="text/javascript">

So these were the improvements that happened in the ScriptManager control for registering scripts. In case you want to refresh your memory, ScriptManager was greatly enhanced in ASP.NET v4.0 and Dave Reed had a fantastic post about it, which I strongly recommend to go through.