var students = new List<Student>
{
    new Student { FirstMidName = "Carson",   LastName = "Alexander", EnrollmentDate = DateTime.Parse("2005-09-01") },
    new Student { FirstMidName = "Meredith", LastName = "Alonso",    EnrollmentDate = DateTime.Parse("2002-09-01") },
    new Student { FirstMidName = "Arturo",   LastName = "Anand",     EnrollmentDate = DateTime.Parse("2003-09-01") },
    new Student { FirstMidName = "Gytis",    LastName = "Barzdukas", EnrollmentDate = DateTime.Parse("2002-09-01") },
    new Student { FirstMidName = "Yan",      LastName = "Li",        EnrollmentDate = DateTime.Parse("2002-09-01") },
    new Student { FirstMidName = "Peggy",    LastName = "Justice",   EnrollmentDate = DateTime.Parse("2001-09-01") },
    new Student { FirstMidName = "Laura",    LastName = "Norman",    EnrollmentDate = DateTime.Parse("2003-09-01") },
    new Student { FirstMidName = "Nino",     LastName = "Olivetto",  EnrollmentDate = DateTime.Parse("2005-09-01") },
};

 students.ForEach(s => context.Students.AddOrUpdate(p => p.LastName, s));
 context.SaveChanges(); 

The first parameter passed to the AddOrUpdate method specifies the property to use to check if a row already exists. For the test student data that we are providing, the LastName property can be used for this purpose since each last name in the list is unique.

An important consideration in many applications is how you handle nearly duplicate data. For example,  how will your application work when you have two students named Alexander Carson. Even very small databases like the NFL players have several members with exactly the same name (for example Steve Smith of the Carolina Panthers and Steve Smith of the St. Louis Rams).

Using the code above, you can’t add another Alexander Carson. You can add another Alexander Carson who enrolled on a different date from the first entry with the following code:

foreach (Student e in students)
{
    var studentInDB = context.Students.Where(
        s => s.FirstMidName == e.FirstMidName &&
        s.LastName == e.LastName  &&
        s.EnrollmentDate == e.EnrollmentDate).SingleOrDefault();
      
    if (studentInDB == null)
    {
        context.Students.Add(e);
    }
}

context.SaveChanges();

While the code above solves the problem of adding another Alexander Carson, it’s not a general solution. You can’t add another Alexander Carson with a duplicate enrolment date. An approach I like to take, especially with larger seed databases, is to add each record one at a time. The following code shows how to do this:

context.Students.Add(new Student { FirstMidName = "Carson", LastName = "Alexander" });
context.SaveChanges();
context.Students.Add(new Student { FirstMidName = "Carson", LastName = "Alexander" });
context.SaveChanges();

You don’t need to call SaveChanges after each Add, but doing so will show you exactly where a problem occurs. For example, when I was working on Jon Galloway’s fabulous MVC Music Store tutorial, I added a minimum string length constraint of 2. Everything worked fine, the constraint worked, I couldn’t add new albums with a name less than 2 characters. At some point I migrated the code to a new system where the migrations code had to insert all the seed data into the DB. The initializer failed with an obscure error. Switching the code to the Add/SaveChanges approach quickly exposed the problem (there was a seed album with a one character name).

While working on this blog, I was getting the following error when running update-database from the Package Manager Console.

Sequence contains more than one element

I couldn’t see how there was any duplicates in my code, so I went into debug mode. Adding System.Diagnostics.Debugger.Break(); to the migrations code caused Visual Studio to shut down and restart. I just happened to see Rowan in the kitchen and he suggested I look at his blog Running & Scripting Migrations From Code. I copy/pasted the following lines from his blog into the about method of my controller and was able to step into and debug the seed method.

public ActionResult About()
{
    var configuration = new Configuration();
    var migrator = new DbMigrator(configuration);
    migrator.Update();
    ViewBag.Message = "Your app description page.";

    return View();
}

It was an excellent message, I had previously added duplicates of Alexander Carson with the Add method, and subsequently deleted that Add code. The debugger quickly showed my problem.  Rowans blog states:

Our team has been careful to ensure that all the operations available as Power Shell commands can be easily performed from your code.

It’s a good idea to run the command update-database multiple times to make sure it works each time (after the 1st run, it shouldn’t make any changes).

Follow me ( @RickAndMSFT )   on twitter where I have a no spam guarantee of quality tweets.

Updated 17 Jan 2013:  Tracing in OnStop is not supported.

An often neglected consideration in Windows Azure is how to handle restarts. It’s important to handle restarts correctly, so you don’t lose data or corrupt your persisted data, and so you can quickly shutdown, restart, and efficiently handle new requests.  Windows Azure Cloud Service applications are restarted approximately twice per month for operating system updates. (For more information on OS updates, see Role Instance Restarts Due to OS Upgrades.) When a web application is going to be shutdown, the RoleEnvironment.Stopping event is raised. The web role boilerplate created by Visual Studio does not override the OnStop method, so the application will have only a few seconds to finish processing HTTP requests before it is shut down. If your web role is busy with pending requests, some of these requests can be lost. You can delay the restarting or your web role by up to 5 minutes by overriding the OnStop method and calling Sleep, but that’s far from optimal. Once the Stopping event is raised, the Load Balance (LB) stops sending requests to the web role, so delaying the restart for longer than it takes to process pending requests leaves your virtual machine spinning in Sleep, doing no useful work. The optimal approach is to wait in the OnStop method until there are no more requests, and then initiate the shutdown. The sooner you shutdown, the sooner the VM can restart and begin processing requests. To implement the optimal shutdown strategy, add the following code to your WebRole class.

public override void OnStop()
{
    Trace.TraceInformation("OnStop called WebRole");
    var pcrc = new PerformanceCounter("ASP.NET", "Requests Current", "");

    while (true)
    {
        var rc = pcrc.NextValue();
        Trace.TraceInformation("ASP.NET Requests Current = " + rc.ToString());
        if (rc <= 0)
            break; 
        System.Threading.Thread.Sleep(1000);
    }
}

The code above checks the ASP.NET request’s current counter. As long as there are requests, the OnStop method calls Sleep to delay the shutdown. Once the current request’s counter drops to zero, OnStop returns, which initiates shutdown. Should the web server be so busy that the pending requests cannot be completed in 5 minutes, the application is shut down anyway. Remember that once the Stopping event is raised, the LB stops sending requests to the web role, so unless you had a massively under sized (or too few instances of) web role, you should never need more than a few seconds to complete the current requests.

The code above writes Trace data, but unless you perform a tricky On-Demand Transfer, the trace data from the OnStop method will never appear in WADLogsTable. Later in this blog I’ll show how you can use DebugView to see these trace events. I’ll also show how you can get tracing working in the web role OnStart method.

Optimal Restarts for Worker Roles

Handling the Stopping event in a worker role requires a different approach. Typically the worker role processes queue messages in the Run method. The strategy involves two global variables; one to notify the Run method that the Stopping event has been raised, and another global to notify the OnStop method that it’s safe to initiate shutdown. (Shutdown is initiated by returning from OnStop.) The following code demonstrates the two global approaches.

public class WorkerRole : RoleEntryPoint
{
    private CloudQueue myWorkQueue;
    private volatile bool onStopCalled = false;
    private volatile bool returnedFromRunMethod = false;

    public override void Run()
    {
        CloudQueueMessage msg = null;
        while (true)
        {
            try
            {
                // If OnStop has been called, return to do a graceful shutdown.
                if (onStopCalled == true)
                {
                    Trace.TraceInformation("onStopCalled WorkerRole");
                    returnedFromRunMethod = true;
                    return;
                }
                // Retrieve and process a new message.
                msg = myWorkQueue.GetMessage();
                if (msg != null)
                {
                    ProcessQueueMessage(msg);
                }
                else
                {
                    System.Threading.Thread.Sleep(1000);
                }
            }
            catch (Exception ex)
            {
                string err = ex.Message;
                if (ex.InnerException != null)
                    err += " Inner Exception: " + ex.InnerException.Message;
                Trace.TraceError(err);
                // Don't fill up Trace storage if we have a bug in  process loop.
                System.Threading.Thread.Sleep(1000);
            }
        }
    }

    public override void OnStop()
    {
        onStopCalled = true;
        Trace.TraceInformation("OnStop called from Worker Role.");
        while (returnedFromRunMethod == false)
        {
            Trace.TraceInformation("Waiting for returnedFromRunMethod");
            System.Threading.Thread.Sleep(1000);
        }
        Trace.TraceInformation("returnedFromRunMethod is true, so restarting");
    }

    private void ProcessQueueMessage(CloudQueueMessage msg)
    {
        // Code omitted for clarity.
        System.Threading.Thread.Sleep(1000);
    }

    private void ConfigDiagnostics()
    {
        // See https://bit.ly/UXM44C
    }

    public override bool OnStart()
    {
        // Code omitted for clarity.

    }
}

When OnStop is called, the global onStopCalled is set to true, which signals the code in the Run method to shut down at the top of the loop, when no queue event is being processed.

Viewing OnStop Trace Data

As mentioned previously, unless you perform a tricky On-Demand Transfer, the trace data from the OnStop method will never appear in WADLogsTable. We’ll use Dbgview to see these trace events. In Solution Explorer, right-click on the cloud project and select Publish.

Download your publish profile.  In the Publish Windows Azure Application dialog box, select Debug and select Enable Remote Desktop for all roles.

The compiler removes Trace calls from release builds, so you’ll need to set the build configuration to Debug to see the Trace data. Once the application is published and running, in Visual Studio, select Server Explorer (Ctl+Alt+S). Select Windows Azure Compute, and then select your cloud deployment. (In this case it’s called t6 and it’s a production deployment.) Select the web role instance, right-click, and select Connect using Remote Desktop.

Remote Desktop Connection (RDC) will use the account name you specified in the publish wizard and prompt you for the password you entered. In the left side of the taskbar, select the Server Manager icon.

In the left tab of Server Manager, select Local Server, and then select IE Enhanced Security Configuration (IE ESC). Select the off radio button in the IE ESC dialog box.

Start Internet Explorer, download and install DebugView. Start DebugView, and in the Capture menu, select Capture Global Win32.

Select the filter icon, and then enter the following exclude filter:

Heartbeat;*is reporting state Ready.;*has current state Started*;*WaIISHost.exe Information:*;*Microsoft.WindowsAzure.ServiceRuntime Information:*;*Invalid parameter passed *;*w3wp.exe Information:*;

For this test, I added the RoleEnvironment.RequestRecycle  method to the About action method, which as the name suggests, initiates the shutdown/restart sequence. Alternatively, you can publish the application again, which will also initiate the shutdown/restart sequence.

Follow the same procedure to view the trace data in the worker role VM. Select the worker role instance, right-click and select Connect using Remote Desktop.

Follow the procedure above to disable IE Enhanced Security Configuration. Install and configure DebugView using the instructions above. I use the following filter for worker roles:

Heartbeat;*is reporting state Ready.;*has current state Started, desired *;*w3wp.exe Information: *;*WaWorkerHost.exe Information*;*Invalid parameter passed *;*Microsoft.WindowsAzure.ServiceRuntime Information:*;

For this sample, I published the Azure package, which causes the shutdown/restart procedure.

One last departing tip: To get tracing working in the web roles OnStart method, add the following:

Trace.Listeners.Add(
   new Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener());

Tracing in OnStop

Tracing in the OnStop method is not supported and not recommended for the following reasons:

1. The OnStop method should be used only to delay shutdown until you’ve processed all pending requests (web role) or completed a unit of work (worker role) so you get a clean shutdown. As stated above, you should return from OnStop (which initiates shutdown) as soon as possible, as soon as you can get your application in a clean shut down state. The OnStop method should be very simple, so you shouldn’t need to trace in this method.
2. OnStop is called from a different process which doesn’t read the trace listener configuration in the app.config (worker role) or web.config (web role) file. To get it working you’d have to configure the azure diagnostics trace listener programmatically to hook up the listener to the agent process that manages the PaaS VM role.
3. There are inherent polling wait times during On-demand transfer of a minute or more.  It is not well suited for execution during the time limited OnStop.

Most of the information in this blog comes from Azure multi-tier tutorial Tom and I published last week. Be sure to check it out for lots of other good tips.

Follow me ( @RickAndMSFT )   on twitter where I have a no spam guarantee of quality tweets.

• Web sites versus web role in a cloud service.
• How to design tables for efficient queries using the new Windows Azure Storage Client Library (SCL) 2.0. The new SCL offers huge performance benefits over the previous SCL.
• How to handle concurrency exceptions in ASP.NET MVC using the SCL. There are a couple tricks to getting it right, but the sample shows it’s easy once you know these.
• How to set the retry policy in SCL 2.0 code for a UI. The SCL 2.0 API automatically retries three times with exponentially increasing timeout limits, something you generally don’t want to do in a web page.
• How to use batch deletes and batch queue fetches to save transaction costs.
• Using nullable types on storage tables containing multiple types (and why it’s important).
• How to optimally shut down web and worker roles. Windows Azure Cloud Service applications are restarted approximately twice per month for operating system updates. When a web application is going to be shut down, an OnStop event is raised. The web role boilerplate created by Visual Studio does not override the OnStop method, so the application will have only a few seconds to finish processing HTTP requests before it is shut down.
• How to write effective OnStart methods. The boilerplate code generated by Visual Studio for the OnStart method uses several obsolete calls such as:
• Trace.WriteLine("Working", "Information");
• ServicePointManager.DefaultConnectionLimit = 12;
• How to effectively use tracing and diagnostics.
• Tips on cost savings.
• Why you should care about affinity. (Currently affinity requires you to navigate to the old portal.)
• Using GUIDs versus Time.Now.Ticks for row keys.
• How to decrease project startup time by disabling the Azure Storage Emulator.

To get detailed error messages on Azure or the compute emulator, you need to add a startup command to your project with the following lines.

%windir%system32inetsrvAppCmd.exe set config -section:system.webServer/httpErrors -errorMode:Detailed
%APPCMD% set config -section:system.webServer/httpErrors -errorMode:Detailed

The first line enables detailed error messages on Azure. The second line enables them on the compute emulator.

Follow the instructions at How to Block Specific IP Addresses from Accessing a Web Role for setting up the startup command, but replace the ipSecurity line with the lines above.

In addition to blogging, I use Twitter to make quick posts and share links. My Twitter handle is: @RickAndMSFT

Using the current Azure SDK and Visual Studio 2012, you may get a HTTP 500 internal error if there is something wrong with your Web.config file.

OK, something went wrong, but what? I actually hit this error last year and blogged the solution – but a lot of changes have taken place with the Azure SDK since then, and last years solution no longer works.

By default, the ApplicationHost.config file does not enable detailed error messages. The solution I blogged last year was to edit this file and update the <httpErrors>  element and add errorMode="Detailed". But that solution no longer works. Previously the Azure compute emulator used IIS, so you could edit %windir%\System32\inetsrv\config\ApplicationHost.config and add detailed errors.  Now the Azure compute emulator uses IIS Express. Given that IIS Express by default uses stores the applicationhost.config  file in C:\Users\<user>\Documents\IISExpress\config ,  I naturally tried to update that file. It turns out that under the Azure compute emulator, IIS Express uses the applicationhost.config  file in a directory exposed with the %APPCMD% environment variable.

Our first step was creating a Azure Table Storage account to contain the email distribution lists. This post contains the essential steps to get Azure Table Storage working with an ASP.NET application.  You must first have an Azure account – you can get one free here.

Create a Windows Azure Storage account

1. Log into the Windows Azure Management Portal.
2. At the bottom of the navigation pane, click Storage, then click New.
   
   
3. Click QUICK CREATE.
   
   
4. Enter a subdomain name in the URL box at the top. In this screen shot I’ve entered 012, so that magic string is taken and you’ll need to enter something unique.  Set the Region/Affinity group to your region. Disable Geo-Replication for this sample.
5. Click CREATE STORAGE ACCOUNT. The storage status page is displayed. It will take about a minute to create your storage account. The image below shows my status page.
   
   
6. Select the storage account you just created. On the bottom of the page, select MANAGE KEYS.
   
   The image below shows my keys for account 012. Hackers take note, the keys are no good, I regenerated them right after taking this screenshot.
   
   
   
   You’ll need the storage account name and one of the keys later in this post.

Install Azure Storage Explorer

You can get Azure Storage Explorer here. Alternatively, you can use CloudBerry.

1. Start Azure Storage Explorer. Select Add Account.
2. Copy your storage account name and access key, then click Add Storage Account.
   
   
3. Click Tables, then click New. To use the code supplied with this post, name the table MailingList, then click Create Table.
   
   
   
   You can go back to Azure Storage Explorer to see the data you insert in your application.

Open the ASP.NET MVC Application to use the Azure Table

1. Open the sample download. Alternatively, you can create a new ASP.NET MVC Internet Application, accept all the defaults.
2. Edit the root web.config file and add the storage connection string. The name doesn’t matter, our sample code uses “StorageConnectionString” for the name.

    <connectionStrings> <add name="StorageConnectionString" connectionString="DefaultEndpointsProtocol=https; AccountName=012; AccountKey=psMemlbL0m+n6/9dKBogusKey+Zom8XWDPY+hIwLb5MnrVSubbY1+m3QlFLTWTIhRZJpeg==" /> </connectionStrings>

3. Run the application and enter a couple email List names. You can see the data in both the application and in Azure Storage Explorer.
   
   
   
   

That was pretty cool – we just ran our ASP.NET MVC application in IIS Express and created data in the cloud!

Deploy the application to Azure

1. From the Azure Portal, click on WEB SITES then NEW.
   
   
2. Click QUICK CREATE, then enter a URL. Click on the Web Site you just created, then click Download publish profile.
   
   
3. Save the publish profile, you will import it in the next step.
4. In Visual Studio, right click on the MvcAES project, and select Publish.
   
   
5. In the Publish Web dialog, select Import.
   
   
6. Navigate to the profile you just downloaded. I like to select Next and review the Connection and Settings entries.  Select Publish. Visual Studio automatically launch your deployed Web Site in your favorite browser.

You can see the data you entered from your desktop and you can edit the data from the cloud.

In addition to blogging, I use Twitter to make quick posts and share links. My Twitter handle is: @RickAndMSFT

The RC and RTM versions of ASP.NET MVC 4 had a bug in the view caching mechanism that resulted in mobile views (and other views specified by inserting a new DefaultDisplayMode)  returning the wrong view.  Initially the correct mobile view would be returned, but when the mobile view expired from the cache (which has a sliding default of 15 minutes) and when the desktop view was still in the cache, a mobile request for the view would return the desktop view. This bug was reported as bug number 280 on CodePlex and in the ASP.NET MVC forum here.

Most applications that hit this problem can simply install the Fixed DisplayModes NuGet package. The ASP.NET Fall 2012 Update includes the Fixed DisplayModes NuGet package in the new project templates.

Applications that customize the collection of registered view engines will need to reference the fixed razor or fixed web forms view engine:

• Microsoft.Web.Mvc.FixedRazorViewEngine
• Microsoft.Web.Mvc.FixedWebFormViewEngine

Applications that remove all the view engines, then add back Razor with the following code:

ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());

Will need to replace the above code with the following:

ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new Microsoft.Web.Mvc.FixedRazorViewEngine());

In addition to blogging, I use Twitter to make quick posts and share links. My Twitter handle is: @RickAndMSFT

1. Declare and register bundles.
2. Consume bundles from within your views. 

This blog entry describes the basics of using B/M in a Web Page site. For an overview and more details on B/M, see my tutorial Bundling and Minification. You can read about B/M for ASP.NET MVC here and for Web Forms here.

To get started, we’ll create a new Web Pages site.

Open the _AppStart.cshtml file.

Replace the contents with the following code:

@using System.Web.Optimization;

@{
     var bundles = BundleTable.Bundles;
     
     bundles.UseCdn =   true;   //enable CDN support

    //add link to jquery on the CDN
    var jqueryCdnPath = "https://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.1.min.js";

    bundles.Add(new ScriptBundle("~/bundles/jquery", 
                jqueryCdnPath).Include(
                "~/Scripts/jquery-{version}.js"));

    bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(
                "~/Scripts/jquery-ui-{version}.js"));

    bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
                "~/Scripts/jquery.unobtrusive*",
                "~/Scripts/jquery.validate*"));

    bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                "~/Scripts/modernizr-*"));

    bundles.Add(new StyleBundle("~/Content/css").Include("~/Content/site.css"));

    bundles.Add(new StyleBundle("~/Content/themes/base/css").Include(
                "~/Content/themes/base/jquery.ui.core.css",
                "~/Content/themes/base/jquery.ui.resizable.css",
                "~/Content/themes/base/jquery.ui.selectable.css",
                "~/Content/themes/base/jquery.ui.accordion.css",
                "~/Content/themes/base/jquery.ui.autocomplete.css",
                "~/Content/themes/base/jquery.ui.button.css",
                "~/Content/themes/base/jquery.ui.dialog.css",
                "~/Content/themes/base/jquery.ui.slider.css",
                "~/Content/themes/base/jquery.ui.tabs.css",
                "~/Content/themes/base/jquery.ui.datepicker.css",
                "~/Content/themes/base/jquery.ui.progressbar.css",
                "~/Content/themes/base/jquery.ui.theme.css"));

}

New to the optimization framework for .Net 4.5 RTM is CDN support (shown in the yellow highlighted code above).

Consuming the Bundles

Open the layout file and replace the script  and CSS link tags in the <head> element with bundle references.  The original code is shown below:

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>@Page.Title - My ASP.NET Web Page</title>
        <link href="~/Content/themes/base/jquery.ui.all.css" rel="stylesheet" type="text/css" />
        <link href="~/Content/Site.css" rel="stylesheet" type="text/css" />
        <link href="~/favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <script src="~/Scripts/jquery-1.7.1.min.js"></script>
        <script src="~/Scripts/jquery-ui-1.8.20.js"></script>
        <script src="~/Scripts/modernizr-2.5.3.js"></script>
        <meta name="viewport" content="width=device-width" />
    </head>

The updated code is shown below.

@using System.Web.Optimization;
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>@Page.Title - My ASP.NET Web Page</title>

         @Styles.Render("~/Content/themes/base/css", "~/Content/css");

        <link href="~/favicon.ico" rel="shortcut icon" type="image/x-icon" />

        @Scripts.Render("~/bundles/jquery",
            "~/bundles/jqueryui",
                     "~/bundles/modernizr");

        <meta name="viewport" content="width=device-width" />
    </head>

With the changes, the CSS and JavaScript can be delivered in bundles. Bundles are referenced in views using the Render method ,  ( Styles.Render for CSS and Scripts.Render for JavaScript).

The default configuration for Web Pages sets the compilation element to debug=true. When the compilation is debug=true, no bundling or minification occurs. Open the Web.config file and change the compilation elements debug attribute to false as shown below:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.web>
    <compilation debug="false" targetFramework="4.0" />
  </system.web>
  <!--Elements removed for clarity.-->
</configuration>

Simple membership initialization failure can occur for the following reasons.

1. The most common reason is the connection string to SQL Server is not valid. For example, you might not have SQL Server available. This is a frequent cause of failure in Azure. The ASP.NET MVC 4 templates by default use SqlExpress when created with Visual Studio 2010 and LocalDB when using Visual Studio 2012. SqlExpress is not installed on Azure and LocalDB does not run on Azure.
2. Multiple DBContext objects on the same database.

The following code shows the InitializeSimpleMembership Attribute code that is added to a new ASP.NET MVC application. The code is found in the Filters folder:

using System;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Threading;
using System.Web.Mvc;
using WebMatrix.WebData;
using MvcV4.Models;

namespace MvcV4.Filters
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class InitializeSimpleMembershipAttribute : ActionFilterAttribute
    {
        private static SimpleMembershipInitializer _initializer;
        private static object _initializerLock = new object();
        private static bool _isInitialized;

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            // Ensure ASP.NET Simple Membership is initialized only once per app start
            LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
        }

        private class SimpleMembershipInitializer
        {
            public SimpleMembershipInitializer()
            {
                Database.SetInitializer<UsersContext>(null);

                try
                {
                    using (var context = new UsersContext())
                    {
                        if (!context.Database.Exists())
                        {
                            // Create the SimpleMembership database without Entity Framework migration schema
                            ((IObjectContextAdapter)context).ObjectContext.CreateDatabase();
                        }
                    }

                    WebSecurity.InitializeDatabaseConnection("DefaultConnection", "UserProfile", "UserId", "UserName", autoCreateTables: true);
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException("The ASP.NET Simple Membership database could not be initialized. For more information, please see https://go.microsoft.com/fwlink/?LinkId=256588", ex);
                }
            }
        }
    }
}

Create a new ASP.NET Web Forms application which targets the .Net 4.5 framework.

Run the application launch the IE F-12 developer tools. Select the Script tab, then use the assets button to view the JavaScript files.

You can select one of the JavaScript files and view it in the left pane. Note the full (non-minimized version) of the files are used.

Creating the jQuery Bundles

Add jQuery, jQuery.UI and jQuery validation to the  BundleConfig class in the App_Start folder. The following code shows the complete class:

using System.Web.Optimization;

public class BundleConfig
{
    public static void RegisterBundles(BundleCollection bundles)
    {
        bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                    "~/Scripts/jquery-{version}.js"));

        bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(
                    "~/Scripts/jquery-ui-{version}.js"));

        bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
                    "~/Scripts/jquery.unobtrusive*",
                    "~/Scripts/jquery.validate*"));

        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"));

        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"));

        bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
            "~/Scripts/modernizr-*"));
    }
}

Register the Bundles

The templates create the code hook up the bundle registration in the Application_Start method in the Global.asax file.

void Application_Start(object sender, EventArgs e)
{
    BundleConfig.RegisterBundles(BundleTable.Bundles);
    AuthConfig.RegisterOpenAuth();
}

Reference the Bundles

Add the jQuery bundles to the <asp:PlaceHolder > markup as shown in the following code:

    <asp:PlaceHolder runat="server">        
         <%: Scripts.Render("~/bundles/modernizr") %>
         <%: Scripts.Render("~/bundles/jquery") %>
         <%: Scripts.Render("~/bundles/jqueryui") %>
    </asp:PlaceHolder>

Comment out the jQuery script references in the ScriptManager tag as shown below:

<body>
    <form runat="server">
    <asp:ScriptManager runat="server">
        <Scripts>
            <%--        
            <asp:ScriptReference Name="jquery" />
            <asp:ScriptReference Name="jquery.ui.combined" />
            --%>
        </Scripts>
    </asp:ScriptManager>
    <header>

CSS Bundles

Examine the Bundle.config file, which contains the markup to create CSS style bundles.

<?xml version="1.0" encoding="utf-8" ?>
<bundles version="1.0">
  <styleBundle path="~/Content/css">
    <include path="~/Content/Site.css" />
  </styleBundle>
  <styleBundle path="~/Content/themes/base/css">
    <include path="~/Content/themes/base/jquery.ui.core.css" />
    <include path="~/Content/themes/base/jquery.ui.resizable.css" />
    <include path="~/Content/themes/base/jquery.ui.selectable.css" />
    <include path="~/Content/themes/base/jquery.ui.accordion.css" />
    <include path="~/Content/themes/base/jquery.ui.autocomplete.css" />
    <include path="~/Content/themes/base/jquery.ui.button.css" />
    <include path="~/Content/themes/base/jquery.ui.dialog.css" />
    <include path="~/Content/themes/base/jquery.ui.slider.css" />
    <include path="~/Content/themes/base/jquery.ui.tabs.css" />
    <include path="~/Content/themes/base/jquery.ui.datepicker.css" />
    <include path="~/Content/themes/base/jquery.ui.progressbar.css" />
    <include path="~/Content/themes/base/jquery.ui.theme.css" />
  </styleBundle>
</bundles>

You can add your own style bundles to the Bundle.config file.

The following markup shows the CSS bundles and JavaScript bundles referenced. Note that you can multiple bundles in one call to the Render method.

<%: Styles.Render("~/Content/themes/base/css", 
                    "~/Content/css") %>
<%: Scripts.Render("~/bundles/modernizr") %>
<%: Scripts.Render("~/bundles/jquery",
                    "~/bundles/jqueryui") %>