This screencast (and the next) are based on a write-up I did about ASP.NET Web Application deployment with Web Deployment Projects a while back.  Multi-media knowledge sharing.  You have to love it!

This is the first video hosted on Vimeo.  What do you think?

I’ve written about the ASP.NET Membership Provider and setup before.  If you missed the post, this introductory video may be for you.

This is one of our first screencasts.  If you have feedback, I’d love to hear it.

Since you have joined me today, though, I might as well offer up a little tip: you can run into trouble, like I did, if you enable your custom profile provider inside of an application which is deployed using a Web Deployment Project.  Everything will run great on your local machine and you’ll probably take an early lunch because you got the code running in no time flat and the build server is happy and all tests pass and, gosh, maybe you’ll just cut out early because it is Friday after all.  But then the first user hits the integration machine and, that’s right, yellow screen of death. Lucky you, just as you’re walking out the door, the user kindly sends the exception message and stack trace:

Value cannot be null. Parameter name: type Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Stack Trace:
[ArgumentNullException: Value cannot be null. Parameter name: type] System.Activator.CreateInstance(Type type, Boolean nonPublic) +2796915 System.Web.Profile.ProfileBase.CreateMyInstance(String username, Boolean isAuthenticated) +76 System.Web.Profile.ProfileBase.Create(String username, Boolean isAuthenticated) +312

User error?  Not this time. Damn!

One hour later… you notice the harmless “Treat as library component (remove the App_Code.compiled file)” setting on the Output Assemblies Tab of your Web Deployment Project.

You have no idea why, but you uncheck it.  You test and everything works great both locally and on the integration machine.  Application users think you’re the best and you’re still going to catch the last half hour of happy hour.  Happy Friday.

1. Membership tables installed? Check.
2. Profile enabled in web.config? Check.
3. SqlProfileProvider connection string set? Check. 
4. Profile properties defined in said web.config file? Check.
5. Write code to set value, read value, build and test. Check. Check. Check. 

Yep, I thought the built-in Profile stuff was pure gold until I noticed how the user-based information is persisted to the database. It’s stored as xml and, well, that was going to be trouble if I ever wanted to query the profile data.  So, I have avoided the super-easy-to-use ASP.NET Profile provider ever since, until this week, when I decided I could use it to store user-specific properties which I am 99% positive I’ll never need to query against ever. 

I opened up my ASP.NET MVC application, completed steps 1-4 (above) in about 3 minutes, started writing my profile get/set code and that’s where the plan broke down.  Oh yeah. That’s right.  Visual Studio auto-generates a strongly-type Profile reference for web site projects but not for ASP.NET MVC or Web Applications.  Bummer. So, I went through the steps of getting a customer profile provider working in my ASP.NET MVC application:

First, I defined a CurrentUser routine and my profile properties in a custom Profile class like so:

And then I replaced the existing profile configuration web.config with the following:

Notice that profile is enabled, I’ve defined the defaultProvider and profile is now inheriting from my custom MemberPreferencesProfile class. 

Finally, I am now able to set and get profile property values nearly the same way as I did with website projects:

The Web Deployment Project type doesn’t come out-of-the-box with Visual Studio 2008.  You’ll need to Download Visual Studio® 2008 Web Deployment Projects – RTW and install if you want to follow along with this tutorial.

I’ve created a shiny new ASP.NET MVC project.  Web Deployment Projects work with websites, web applications and MVC projects so feel free to go with any web project type you’d like. 

Once your web application is in place, it’s time to add the Web Deployment project.  You can hunt and peck around the File > New > New Project… dialogue as long as you’d like, but you aren’t going to find what you need.  Instead, select the web project and then choose the “Add Web Deployment Project…” hiding behind the Build menu option.

I prefer to name my projects based on the environment in which I plan to deploy.  In this case, I’ll be rolling to the QA machine.

Don’t expect too much to happen at this point.  A seemingly empty project with a funny icon will be added to your solution.  That’s it.

I want to take a minute and talk about configuration settings before we continue.  Some of the common settings which might change from environment to environment are appSettings, connectionStrings and mailSettings.  Here’s a look at my updated web.config:

I want to update these values prior to deploying to the QA environment.  There are variations to this approach, but I like to maintain environment-specific settings for each of the web.config sections in the Config/[Environment] project folders.  I’ve provided a screenshot of the QA environment settings below.

It may be obvious what one should include in each of the three files.  Basically, it is a copy of the associated web.config section with updated setting values.  For example, the AppSettings.config file may include a reference to the QA web url, the DB.config would include the QA database server and login information and the StmpSettings.config would include a QA Stmp server and user information.

AppSettings.config 

Db.config 

SmtpSettings.config 

I think our web project is ready to deploy.  Now, it’s time to concentrate on the Web Deployment Project itself.  Right-click on the project file and open the Property Pages.

The first thing to call out is the Configuration dropdown.  I only deploy a project which is built in Release Mode so I only setup the Web Deployment Project for this mode.  (This is when you change the Configuration selection to “Release.”)  I typically keep the Output Folder default value – .\Release\.  When the application is built, all artifacts will be dropped in the .\Release\ folder relative to the Web Deployment Project root.  The final option may be up for some debate.  I like to roll out updatable websites so I select the “Allow this precompiled site to be updatable” option.  I really do like to follow standard SDLC processes when I release my software but there are those times when you just have to make a hotfix to production and I like to keep this option open if need be.  If you are strongly opposed to this idea, please, by all means, don’t check the box.

The next tab is boring.  I don’t like to deploy a crazy number of DLLs so I merge all outputs to a single assembly.  Again, you may have another option and feel free to change this selection if you so wish.

If you follow my lead, take care when choosing a single assembly name.  The Assembly Name can not be the same as the website or any other project in your solution otherwise you’ll receive a circular reference build error.  In other words, I can’t name the assembly MvcApplication293 or my output window would start yelling at me.

Remember when we called out our QA configuration files?  Click on the Deployment tab and you’ll see how where going to use them.  Notice the Web.config file section replacements value.  All this does is swap called out web.config sections with the content of the Config\QA\* files.  You can reduce or extend this list as you deem fit. 

Did you see the “Use external configuration source file” option?  You know how you can point any of your web.config sections to an external file via the configSource attribute?  This option allows you to leverage that technique and instead of replacing the content of the sections, you will replace the configSource attribute value instead.

Go ahead and Apply your changes.  I’d like to take a look at the project file we just updated.  Right-click on the Web Deployment Project and select “Open Project File.”

One of the first configuration blocks reflects core Release build settings.  There are a couple of points I’d like to call out here:

• DebugSymbols=false ensures the compilation debug attribute in your web.config is flipped to false as part of build process.  There’s some crumby (more likely old) documentation which implies you need a ToggleDebugCompilation task to make this happen.  Nope. Just make sure the DebugSymbols is set to false. 

• EnableUpdateable implies a single dll for the web application rather than a dll for each object and and empty view file. I think updatable applications are cleaner and include the benefit (or risk based on your perspective) that portions of the application can be updated directly on the server.  I called this out earlier but I wanted to reiterate.

The next section is self-explanatory.  The content merely reflects the replacement value you provided via the Property Pages.

You’ll want to extend the ItemGroup section to include the files you wish to exclude from the build.  The sample ExcludeFromBuild nodes exclude all obj, svn, csproj, user, pdb artifacts from the build. Enough though they files aren’t included in your web project, you’ll need to exclude them or they’ll show up along with required deployment artifacts. 

Pre/post build and Pre/post merge tasks are added to the final code block.  By default, your project file should look like the following – a completely commented out section.

Update the section to remove all temporary Config folders and files after the build. 

That’s it for setup.  Save the project file, flip the solution to Release Mode and build.  If there’s an issue, consult the Output window for details.  If all went well, you will find your deployment artifacts in your Web Deployment Project folder like so.

Both the code source and published application will be there. Inside the Release folder you will find your “published files” and you’ll notice the Config folder is no where to be found.  In the Source folder, all project files are found with the exception of the items which were excluded from the build.

I’ll wrap up this tutorial by calling out a little Web Deployment pet peeve of mine: there doesn’t appear to be a way to add an existing web deployment project to a solution.  The best I can come up with is create a new web deployment project and then copy and paste the contents of the existing project file into the new project file.  It’s not a big deal but it bugs me.

For the record, this is how I currently manage my meta:

All Master pages assume the same keywords and description values as defined by the application settings.  Nothing fancy. Nothing dynamic. But it’s manageable.  It works, but I’m looking forward to the new way in ASP.NET 4.

First, you’ll find the ApplicationServices database connection:

Notice the connection string is referencing the aspnetdb.mdf database hosted by SQL Express and it’s using integrated security so it’ll just work for you without having to call out a specific database login or anything.

Scroll down the file a bit and you’ll find each of the three noted sections:

Really. It’s all there. Still don’t believe me.  Run the application, walk through the registration process and finally login and logout.  Completely functional – and you didn’t have to do a thing!

What else?  Well, you can manage your users via the Configuration Manager which is hiding in Visual Studio behind Projects > ASP.NET Configuration.

The ASP.NET Web Site Administration Tool isn’t MVC-specific (neither is the Membership, Profile or RoleManager stuff) but it’s neat and I hardly ever see anyone using it.  Here you can set up and edit users, roles, and set access permissions for your site. You can manage application settings, establish your SMTP settings, configure debugging and tracing, define default error page and even take your application offline.  The UI is rather plain-Jane but it works great.

And here’s the best of all.  Let’s say you, like most of us, don’t want to run your application on top of the aspnetdb.mdf database.  Let’s suppose you want to use your own database and you’d like to add the membership stuff to it.  Well, that’s easy enough. Take a look inside your [drive:]\%windir%\Microsoft.Net\Framework\v2.0.50727\ folder.  Here you’ll find a bunch of files.  If you were to run the InstallCommon.sql, InstallMembership.sql, InstallRoles.sql and InstallProfile.sql files against the database of your choices, you’d be installing the same membership, profile and role artifacts which are found in the aspnet.db to your own database. 

Too much trouble?  Okay. Run [drive:]\%windir%\Microsoft.Net\Framework\v2.0.50727\aspnet_regsql.exe from the command line instead.  This will launch the ASP.NET SQL Server Setup Wizard which walks you through the installation of those same database objects into the new or existing database of your choice. You may not always have the luxury of using this tool on your destination server, but you should use it whenever you can. 

Last tip: don’t forget to update the ApplicationServices connectionstring to point to your custom database after the setup is complete.

At the risk of sounding like a smarty, everything I’ve mentioned in this post has been around for quite a while. The thing is that not everyone has had the opportunity to use it.  And it makes sense. I know I’ve worked on projects which used custom membership services.  Why bother with the out-of-the-box stuff, right?   And the .NET framework is so massive, who can know it all. Well, eventually you might have a chance to architect your own solution using any implementation you’d like or you will have the time to play around with another aspect of the framework.  When you do, think back to this post.

But let’s say you need to provide both plain text and HTML versions of your message body.  Or maybe you would like to embed an image or two within the message body.  Or, what if, for some reason, you actually want to handle exceptions appropriately.  Well, there’s more to it then.

There are a numerous ways to better organize the following code.  In fact, we just went through an exercise at work where we refactored the heck out of the core email functionality and produce a really clean usable component which can be easily mocked, configured and leverages email templates.  It’s pretty cool.  That being said, I believe the following sample demonstrates the aforementioned core features of .NET emailing. 

I hope it helps. Let me know if I missed anything or it the example could be more clear.

try
{
    // Assign a sender, recipient and subject to new mail message
    MailAddress sender =
        new MailAddress("sender@johnnycoder.com", "Sender");

    MailAddress recipient =
        new MailAddress("recipient@johnnycoder.com", "Recipient");

    MailMessage m = new MailMessage(sender, recipient);
    m.Subject = "Test Message";

    // Define the plain text alternate view and add to message
    string plainTextBody =
        "You must use an email client that supports HTML messages";

    AlternateView plainTextView =
        AlternateView.CreateAlternateViewFromString(
            plainTextBody, null, MediaTypeNames.Text.Plain);

    m.AlternateViews.Add(plainTextView);

    // Define the html alternate view with embedded image and
    // add to message. To reference images attached as linked
    // resources from your HTML message body, use "cid:contentID"
    // in the <img> tag...
    string htmlBody =
        "<html><body><h1>Picture</h1><br>" +
        "<img src=\"cid:SampleImage\"></body></html>";

    AlternateView htmlView =
        AlternateView.CreateAlternateViewFromString(
            htmlBody, null, MediaTypeNames.Text.Html);

    // ...and then define the actual LinkedResource matching the
    // ContentID property as found in the image tag. In this case,
    // the HTML message includes the tag
    // <img src=\"cid:SampleImage\"> and the following
    // LinkedResource.ContentId is set to "SampleImage"
    LinkedResource sampleImage =
        new LinkedResource("sample.jpg",
            MediaTypeNames.Image.Jpeg);
    sampleImage.ContentId = "SampleImage";

    htmlView.LinkedResources.Add(sampleImage);

    m.AlternateViews.Add(htmlView);

    // Finally, configure smtp or alternatively use the
    // system.net mailSettings
    SmtpClient smtp = new SmtpClient
          {
              Host = "smtp.bigcompany.com",
              UseDefaultCredentials = false,
              Credentials =
                  new NetworkCredential("username", "password")
          };

    //<system.net>
    //    <mailSettings>
    //        <smtp deliveryMethod="Network">
    //            <network host="smtp.bigcompany.com"
    //              port="25" defaultCredentials="true"/>
    //        </smtp>
    //    </mailSettings>
    //</system.net>

    smtp.Send(m);
}
catch (ArgumentException)
{
    throw new
        ArgumentException("Undefined sender and/or recipient.");
}
catch (FormatException)
{
    throw new
        FormatException("Invalid sender and/or recipient.");
}
catch (InvalidOperationException)
{
    throw new
        InvalidOperationException("Undefined SMTP server.");
}
catch (SmtpFailedRecipientException)
{
    throw new SmtpFailedRecipientException(
        "The mail server says that there is no mailbox for recipient");
}
catch (SmtpException ex)
{
    // Invalid hostnames result in a WebException InnerException that
    // provides a more descriptive error, so get the base exception
    Exception inner = ex.GetBaseException();
    throw new SmtpException("Could not send message: " + inner.Message);
}

I first wrestled with IIS7 when I attempted to get SubText to run in Integrated Pipeline Mode:

Out of the box, SubText is unable to run under IIS7′s Integrated Pipeline Mode. Unfortunately, it goes beyond "migrating" the web.config to match the required format. For example, moving httpModules and httpHandlers to their new location within. As it turns out, Request is not available at Application_Start when running in Integrated mode and this causes SubText to fail too.

If we weren’t adding blog functionality to an existing, GoDaddy-hosted ASP.NET web site, we would be left with two options: Update the SubText codebase to not use the request context (plus fix whatever else surfaces) OR simply run SubText in classic mode.

Unfortunately, our current GoDaddy account is limiting as only a single app pool is available to us. Since the main site is configured for Integrated Pipeline Mode, we don’t have the freedom to change the IIS mode without impacting (read: breaking) the main site.

Short of switching to a more flexible host, the current plan is to modify the main site to run in classic mode. It’s a simple site and reverting the web.config to the classic mode format should not be a big deal. Alternatively, I’m toying with the idea of updating the SubText codebase to not use the request context at Application_Start. I haven’t heard on anyone running SubText in Integrated Mode and it might be a nice problem to solve — assuming there’s an end to the necessary updates.

Assuming there are about 8 more hours allocated to this effort, what’s the best approach? Am I missing any other options?

Ultimately, we settled and opted to run the Subtext in IIS7 but in Classic Mode:

As a follow up, we quickly commented out the Application_Start code which referenced the Request context. This experiment resulted in further exceptions. We’re currently moving forward with medications to the main site to run in classic mode.

Since my IIS7 initiation, I’ve started to get the swing of things.  Sure one needs to jump through a few hoops to get things running, but in retrospect it is all reasonable and once your get some of the basic steps down, it is pretty darn easy.  Hence, I offer three simple tips:

1 – Pretty much everything in IIS7 is locked down by default.  I’m pretty sure you can serve up an HTML page out of the box, but you need to enable even the most basic options like ASP.NET Services and Windows Authentication. Along those lines, here are two of the better articles I found on installing IIS7 on Windows Server 2008 and setting up IIS7 applications.

2 – Another big gotcha is related to configuration locking.  Basically, you need to unlock your web.config modules and handles sections before they can be formatted per IIS7 compliance. Execute the following at the command prompt and you are good to go:

%systemroot%\system32\inetsrv\APPCMD.EXE unlock config -section:system.webServer/modules

%systemroot%\system32\inetsrv\appcmd.exe unlock config -section:system.webServer/handlers

3 – Finally, let AppCmd.exe do your heavy lifting and make your web.config to IIS7 compliant by executing a like migration command:

%systemroot%\system32\inetsrv\APPCMD.EXE migrate config "Default Web Site/Application"

That’s it. Easy, right? By the way, if you are interested in learning more about IIS7, I highly recommend Jeff Brand’s Spaghetti Code Podcast on IIS7 with Robert Boedigheimer and I again suggest you check out the IIS Site.

I know it’s a bit of a tease, but I’m going to save my “What is OAP” post for another day.  Right now, I’m going to show you some code.

Postsharp is an open source library which encapsulate aspects as custom attributes and adds new behaviors to your code through policy injection (which is just another name for AOP.) 

Smelly, Old Code

The follow code serves as an example of a crosscutting concern (Cache) which needs to be separated from the base program and modularized into an aspect.  Notice the offending code checks the cache and queries the database.  It laughs in the face of the Single Responsibility Principle.

private const string KeyNumber = "RandomNumber";

private int GetNumber()
{
    int value;
    if (!CacheHelper.Get(KeyNumber, out value))
    {
        value = DataAccess.GetNumberRandom();
        CacheHelper.Add(value, KeyNumber);
    }

    return value;
}

Shiny, Happy Code

Using PostSharp, GetNumber() is left to do one thing (query the database) and all the caching checks are handled by the aspect, the custom CacheAttribute.  Notice this is all hooked up by decorating GetNumber() with the CacheAttribute tag which accepts the key in the constructor.

private const string KeyNumber = "RandomNumber";

// Pass the key associated with the cached item in the constructor
[Cache(KeyNumber)]
private int GetNumber()
{
    // This logic is only executed if the CacheAttribute calls upon it.
    return DataAccess.GetNumberRandom();
}

The attribute’s logic is basic but very powerful.  When the GetNumber (or any other method which is decorated with the CacheAttribute)  is invoked, CacheAttribute checks to see if the data is in cache using the provided key.  If so, the data is extracted and returned. Period. The GetNumber method is completely bypassed and never executed.  In the sample application, I added some logging to help clarify this point.  However, if the data is not found in cache, the custom attribute invokes the caller, the GetNumber() method, stores the result in cache and then returns the value.  In this case, GetNumber’s logic is executed but it is invoke via the CacheAttribute. 

using System;
using PostSharp.Laos;

namespace PostSharpWebApplicationCache
{
    [Serializable]
    public sealed class CacheAttribute : OnMethodInvocationAspect
    {
        private readonly string key;

        public CacheAttribute(string key)
        {
            this.key = key;
        }

        public override void OnInvocation(MethodInvocationEventArgs context)
        {
            object value;

            if (!CacheHelper.Get(key, out value))
            {
                // Do lookup based on caller's logic.
                value = context.Delegate.DynamicInvoke();
                CacheHelper.Add(value, key);
            }

            context.ReturnValue = value;
        }
    }
}

As you can see, both the smelly, old code and the shiny, happy code achieve the same effect, but the latter option is a lot cleaner and more elegant if you ask me.

As noted, I’ve included some downloaded code if you want to play around with Postsharp and AOP on your own.  To get the code to work, you’ll need to visit the Postsharp site and install the latest bits.  In my case, I’m using PostSharp 1.0.  Please don’t be fooled.  You’ll need to use an ASP.NET Web Application Project rather than ASP.NET Web Site in order for PostSharp to work.  This is because Postsharp does compile-time weaving and cleverly mucks with your IL. Details.  Don’t worry. we’ll get into all of it.  For now, just trust me and know the sample project is a Web Application Project.  Enjoy.

As you’ll see in the examples, jTemplates provides custom syntax to do such things as iterate through Json data and populate a predefined template.  Once you get a grasp of the syntax and the proper usage, you will be ready to roll.  Getting started is easy — just download the latest jQuery and jTemplate bits and reference them within your html or aspx file.

Next, you need to define and host your templates.  In the included sample project, I’ve defined two templates to aid in the population of my dropdown and my table respectively.  Here you will notice the dropdown template merely adds a singe “Select One” entry and then iterates over all project results adding a new option for each:

<%-- Project Dropdown Template --%>
<script type="text/html" id="TemplateProjectSelect">
<option value="">Select One</option>
{#foreach $T.result as project}
    <option value="{$T.project.id}">{$T.project.name}</option>
{#/for}
</script>

And the following table template is a little more complex but still very to interpret.  Here, we are iterating over each task row and appending a new row to the table for each.  Notice there’s a MAIN template and a ROW template.  The MAIN template passes along the current record to the ROW template.  The ROW template sets the appropriate class (think table zebra stripes) and column values based on the current “cycle.”

<%-- Results Table Template --%>
<script type="text/html" id="TemplateResultsTable">
{#template MAIN}
<table width="500" border="0" cellpadding="5" cellspacing="0">
  <tr>
    <th width="50">ID</th>
    <th width="300">Task</th>
    <th width="104">Hours</th>
  </tr>
  {#foreach $T.result as task}
    {#include ROW root=$T.task}
  {#/for}
</table>
{#/template MAIN}

{#template ROW}
<tr class="{#cycle values=['','evenRow']}">
  <td>{$T.id}</td>
  <td>{$T.name}</td>
  <td>{$T.hours}</td>
</tr>
{#/template ROW}
</script>

How’s about hosting the templates?  You have a few options.  First, you could save the templates off in their own file.  This is the approach Dave Ward took in his article. Though this approach is clean, it doesn’t perform all that well.  The preferred approach is to “embed” your templates within the html/aspx file by wrapping each of the above templates with a script tag like so:

<script type="text/html" id="TemplateResultsTable"> 

... template here ...

</script> 

As shared on Rick Strahl’s post, this is the preferred approach as using <script type=”text/html”> that allows hiding any markup in the document without interfering with HTML validators. The script can be accessed by its ID and the content retrieved using the jQuery .html() syntax.

Once your template is in place, you simply need to assign your template to your container (a div) and then process the template using your Json data.  As noted above, you may reference an external template using the following:

$('#tasks').setTemplate('Template.htm');

Or you may select the template from the html/aspx itself:

$('#tasks').setTemplate($("#TemplateResultsTable").html());

Again, the preferred approach is the latter.  In either case, you process the template data (results) as follows:

$('#tasks').processTemplate(results);

A quick note on .processTemplate.  You don’t actually have to provide any data.  You can send null into the processTemplate method if, for example, no processing is required.  In the downloadable example, I create a static template which acts as a place holder when my page first loads and no table data is available. Here’s the sample template and javascript:

<%-- Emtpy Table Template --%>
<script type="text/html" id="TemplateResultsEmpty">
Select a client and project...
</script>

$('#tasks').setTemplate($("#TemplateResultsEmpty").html());
$('#tasks').processTemplate(null);

Before I wrap things up, I should mention the downloadable sample project doesn’t only show off jTemplates.  It also demonstrates how to use jQuery and an “parameterized” HTTPHandler to pull back Json data which is somewhat an extension of my earlier HTTPHandler post.

Have you ever seen this code?  It is front and back of an ASPX file with the single responsibility to return JSON data per an AJAX request.

GetDataPage.aspx

<%@ Page Language="C#" AutoEventWireup="true"
    CodeFile="GetDataPage.aspx.cs" Inherits="GetDataPage" %>
<%--
    This minimal code is here to prevent the following error:
     "Using themed css files requires a header control on the page"
     Please see http://www.west-wind.com/WebLog/posts/4662.aspx
     for more information --%>
<head id="Head1" runat="server" visible="false" />

GetDataPage.aspx.cs

using System;
using System.Web;
using System.Text;

public partial class GetDataPage : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        // Clear out the buffer
        Response.ClearHeaders();
        Response.ClearContent();
        Response.Clear();

        // Do not cache response
        Response.Cache.SetCacheability(HttpCacheability.NoCache);

        // Set the content type and encoding for JSON
        Response.ContentType = "application/json";
        Response.ContentEncoding = Encoding.UTF8;

        int page = int.Parse(Request["p"]);
        string results = DataAccess.GetResults(page);

        Response.Write(results);

        // Flush the response buffer
        Response.Flush();

        // Complete the request.  NOTE: Do not use Response.End() here,
        // because it throws a ThreadAbortException, which cannot be caught!
        HttpContext.Current.ApplicationInstance.CompleteRequest();
    }
}

You may have noticed there’s a comment for nearly every code block.  At first, one may find the comments redundant and unnecessary, but really they are call for help.  A code:comment ratio like this usually indicates you really need to focus on what’s happening with the code because if you aren’t paying attention, bad things might happen.

As you have undoubtedly concluded, there’s a lot of overhead associated with returning JSON data from an ASPX file.  This statement is especially true if you consider the alternative, an HTTPHandler.  Here’s a cleaner, best-practices approach which provides the same outcome with less code, comments and risk.

GetDataHandler.ashx

<%@ WebHandler Language="C#" Class="GetDataHandler" %>

using System.Text;
using System.Web;

public class GetDataHandler : IHttpHandler
{
    public bool IsReusable
    {
        get { return false; }
    }

    public void ProcessRequest (HttpContext context)
    {
        context.Response.ContentType = "application/json";
        context.Response.ContentEncoding = Encoding.UTF8;

        int page = int.Parse(context.Request["p"]);
        string results = DataAccess.GetResults(page);

        context.Response.Write(results);
    }
}

If you are already accustomed to using generic handlers to stream back images, XML, JSON data, etc, this post was probably a bore. But it’s sometimes easy to forget what’s available to you in the vast .NET stack, so hopefully you appreciate the friendly reminder.  In either case, it still surprises me how many examples use the ASPX approach.  In fact, the practice is common enough that I sometimes wonder if there’s an HTTPHandler gotcha to which I’m not privy .  If I am missing something, please let me know.

If you’re still interested, attached you’ll find code which populates two jQuery Flexbox controls using JSON data provided through an ASPX and ASHX files.  This may be worthwhile download if you’re interest in the generic handler code or you want a further look at Flexbox in action after last week’s post.

Microsoft acquired Dundas Data Visualization Intellectual Property in April 2007 and is integrating this technology in different Microsoft products. New Chart and Gauge report items were already released as part of SQL Reporting Services 2008. We also announced the new Map report item which will be available in the next release of SSRS. Microsoft Chart controls (ASP.NET and Windows Forms), released at PDC 2008, also based on the source code acquired from Dundas! Microsoft Chart control is available as a separate installation for .NET Framework 3.5 SP1 and will be part of .NET Framework 4.0.

I’ve used Dundas products for quite some time and they have been very solid.  The only place the product falls down is when one wishes to include Dundas charts as high-quality, printable images embedded within a PDF, for example. If you are interested in knowing more about the printing limitations, I can dig up some of the why-my-reports-look-great-online-but-look-like-crap-on-paper documentation I’ve compiled over the years.

• Download the free Microsoft Chart Controls
• Download the VS 2008 Tool Support for the Chart Controls
• Download the Microsoft Chart Controls Samples
• Download the Microsoft Chart Controls Documentation
• Visit the Microsoft Chart Control Forum

protected void btnExport_Click(object sender, EventArgs e)
{
    // Reference your own GridView here
    if (AccountGrid.Rows.Count > 65535)
    {
        DisplayError("Export to Excel is not allowed" +
            "due to excessive number of rows.");
        return;
    }

    string filename = String.Format("Results_{0}_{1}.xls",
        DateTime.Today.Month.ToString(), DateTime.Today.Year.ToString());

    Response.Clear();
    Response.AddHeader("Content-Disposition", "attachment;filename=" + filename);
    Response.Charset = "";

    // SetCacheability doesn't seem to make a difference (see update)
    Response.Cache.SetCacheability(System.Web.HttpCacheability.NoCache);  

    Response.ContentType = "application/vnd.xls";

    System.IO.StringWriter stringWriter = new System.IO.StringWriter();
    System.Web.UI.HtmlTextWriter htmlWriter = new HtmlTextWriter(stringWriter);

    // Replace all gridview controls with literals
    ClearControls(AccountGrid);

    // Throws exception: Control 'ComputerGrid' of type 'GridView'
    // must be placed inside a form tag with runat=server.
    // ComputerGrid.RenderControl(htmlWrite);

    // Alternate to ComputerGrid.RenderControl above
    System.Web.UI.HtmlControls.HtmlForm form
        = new System.Web.UI.HtmlControls.HtmlForm();
    Controls.Add(form);
    form.Controls.Add(AccountGrid);
    form.RenderControl(htmlWriter);

    Response.Write(stringWriter.ToString());
    Response.End();
}

private void ClearControls(Control control)
{
    for (int i = control.Controls.Count - 1; i >= 0; i--)
    {
        ClearControls(control.Controls[i]);
    }

    if (!(control is TableCell))
    {
        if (control.GetType().GetProperty("SelectedItem") != null)
        {
            LiteralControl literal = new LiteralControl();
            control.Parent.Controls.Add(literal);
            try
            {
                literal.Text =
                    (string)control.GetType().GetProperty("SelectedItem").
                        GetValue(control, null);
            }
            catch
            {}
            control.Parent.Controls.Remove(control);
        }
        else if (control.GetType().GetProperty("Text") != null)
        {
            LiteralControl literal = new LiteralControl();
            control.Parent.Controls.Add(literal);
            literal.Text =
                (string)control.GetType().GetProperty("Text").
                    GetValue(control, null);
            control.Parent.Controls.Remove(control);
        }
    }
    return;
}

Update: 7/30/2008

I previously noted that SetCacheability doesn’t seem to make a difference.  Well, I was right…until I deployed my code to a site behind SSL.  As it turns out, in order for Internet Explorer to open documents in Office (or any out-of-process, ActiveX document server), Internet Explorer must save the file to the local cache directory and ask the associated application to load the file by using IPersistFile::Load.

http://support.microsoft.com/default.aspx?scid=KB;EN-US;q316431&

If the file is not stored to disk, this operation fails. When Internet Explorer communicates with a secure Web site through SSL, Internet Explorer enforces any no-cache request. If the header or headers are present, Internet Explorer does not cache the file. Consequently, Office cannot open the file.

RESOLUTION: Web sites that want to allow this type of operation should remove the no-cache header or headers. In other words, comment out the following line of code particularly if you are running under SSL:

Response.Cache.SetCacheability(System.Web.HttpCacheability.NoCache); 

Additional Comments

Per Jinath Blog, if you are using an UpdatePanel, you may get a System.WebForms.PageRequestManagerParserErrorException exception.  The solution is to add a PostBackTrigger and give it’s ControlID as the excel export button’s ID or you can move your excel export button out side of the update panel.  I verified both options and they work great.  I ultimately went with the former option as such:

    ...
    </ContentTemplate>
    <Triggers>
        <asp:PostBackTrigger ControlID="btnExport" />
    </Triggers>
</asp:UpdatePanel>
...

Per ASPAlliance, you may encounter issues a number of issues which require the following solution.  Check out the link (and the comments) for more details if you get stuck.  I only encountered #1 on the list.

1. You may get an exception which states your Control ‘Grid’ of type ‘GridView’ must be placed inside a form tag with runat=server.  I overcame this by dynamically adding a form to the page and then the GridView to the form before RenderContent().  This solution came per the aforementioned post’s comments.
2. You may need to included the following page directive: EnableEventValidation=”false”.  I didn’t need to include this directive.
3. You may need Override the VerifyRenderingInServerForm Method.  I didn’t need to do so because I added my GridView control to a “mocked” form.
    

Per Dipal Choksi, one can format the spreadsheet results in a generic manner by replacing all controls within the GridView with Literals.  This is reflected in the ClearControls() method above.  My prior implementation merely cleaned up the links associated with the sort functionality tied to the sortable headers.  This solution tackles all cells.

Additional Reference: GridViewGuy 

You may have noticed that .NET Framework installs have gotten unacceptably large since the 1.0 days:

• .NET Framework 1.0 Redist: 19.7MB
• .NET Framework 1.1 Redist: 23.1MB
• .NET Framework 2.0 Redist: 22.4MB
• .NET Framework 3.0 Redist: 50.3MB ( x86 )
• .NET Framework 3.0 Redist: 90.1MB ( x64 )
• .NET Framework 3.5 Redist: 197.0MB

With consideration for the distribution size of the .NET 3.* releases, I should be thankful for the “online” version, but I’m not.  The “online” version is still too big especially if you know the ultra-slim Microsoft .NET Framework 3.5 Client Profile (BETA) weighs in at a mere 217 KB by containing only a subset of features (Common Language Runtime, ClickOnce, Windows Forms, Windows Presentation Foundation and Windows Communication Foundation) found in the full installation of the .NET Framework.

To add to my turmoil, I already know that both of my applications can use the bootstrapper as confirmed by selecting the “Client-only Framework subset” option within my project properties followed by a rebuild without warnings.

But, alas, the Client Profile installer is still in BETA with no published final release date other than “this summer.”  The fact that it is still in BETA isn’t a deal breaker, but the BETA version does put the end user in a less-than-optimal place when it comes to managing future .NET Framework installs.  Per the documentation:

The Microsoft .NET Framework 3.5 SP1 Client (BETA) cannot be upgraded to the full .NET Framework. Users will need to uninstall the .NET Framework 3.5 SP1 Client (BETA) before installing .NET Framework 3.5 SP1. This will be corrected with the final release of .NET Framework 3.5 SP1.

That last sentence haunts me….

Maybe I’m being overly sensitive but I don’t want my users having to uninstall .NET if they choose/need to upgrade the .NET framework.  After all, the primary reason I am packaging up the .NET installer in the first place is for the sake of user convenience (and I suspect the majority of user’s aren’t all the tech-savvy.) 

I am left weighing my options.  I can either stick with the sub par “Online” version of the installer and cause .NET Framework upgrade grief for my user’s going forward OR I can improve the install experience of my product by distributing the Client Profile installer thus causing possible future inconvenience.  Right now, I am leaning towards the former option, but I could be steered otherwise — especially if the final version of the Client Profile installer were released, let’s say, this afternoon. 

I’m torn. What would you do? 

* Side note: I would love to exclude the .NET installer and only download it to the client’s machine and install if needed, but I feel my current approach is reasonable for now. That being said, I’m sure I will be messing around with this alternative option soon.  I’m currently using Inno Setup which can seemly do anything so there’s hope.

References:

1. .NET Framework Size – Christopher Painter
2. .NET 3.5 Framework Distribution Size – Rick Strahl
3. Visual Studio 2008 and .NET Framework 3.5 Service Pack 1 Beta – Scott Guthrie

First you need to define your CSS class which sets the background to a referenced image. 

.icon-cancel {
    background: url(../images/icons/cancel.gif) no-repeat left top;
    display:inline;
    padding-left:18px;
    margin-left: 10px;
    padding-right:10px;
}

Once defined, assign the class to your hyperlink.

<a href="#" class="icon-cancel">Cancel</a>

You may need to play with padding and margin, but you will end up with something similar to the following result:

I used this technique to pretty up a very plain GridView display by applying classes to my edit, update and cancel linkbuttons today.  All it took was the creation of a few more CSS classes and linkbutton class tag updates. 

<asp:TemplateField ShowHeader="False">
    <EditItemTemplate>
        <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="True"
            CommandName="Update" class="icon-save" Text="Update"></asp:LinkButton>
        <asp:LinkButton ID="LinkButton2" runat="server" CausesValidation="False"
            CommandName="Cancel" class="icon-cancel" Text="Cancel"></asp:LinkButton>
    </EditItemTemplate>
    <ItemTemplate>
        <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="False"
            CommandName="Edit" class="icon-edit" Text="Edit"></asp:LinkButton>
    </ItemTemplate>
</asp:TemplateField>

I ran into a strange case this evening.  Rendered text can not be copied to the clipboard after posting back a page containing an UpdatePanel. 

Here’s a simple use case:

1. User enters client name and clicks button to request phone number.
2. Page posts back and displays phone number.
3. User selects the phone number, CTRL+C and attempted to CTRL+V into their contact list.
4. User gets frustrated because the phone number was selectable but apparently could not be copied.

One might assume only the phone number can’t be copied.  Maybe the changing of the text and visible properties of the associated ASP:Label control is to blame.  Well, that’s not the case.  ALL text on the page can no longer be copied after the postback. 

Basically, add an UpdatePanel to a page, postback and you can’t copy anything to the clipboard.  By the way, I discovered the problem while using FireFox 2.0. I tested against IE 7 and I wasn’t able to duplicate the experience.

Try out the most simplistic example I could come up with below.  It might surprise you.

<%@ Page Language="C#" %>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Untitled Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <asp:UpdateProgress ID="UpdateProgress1" runat="server">
        <ProgressTemplate>
            <img id="Img1" runat="server" src="AjaxIndicator.gif"/>
        </ProgressTemplate>
    </asp:UpdateProgress>
    <asp:ScriptManager ID="scriptManager" runat="server">
    </asp:ScriptManager>
    <asp:UpdatePanel ID="updatePanel" runat="server">
        <ContentTemplate>
        <asp:Label ID="message" runat="server">
            This is asp:Label text inside the update panel
                and it can be selected and copied only
                before the postback but not after.</asp:Label>
        <br />
        <br />
            This is regular text inside the update panel
                and it acts the same.
        <br />
        <br />
        <asp:Button ID="button" runat="server" Text="Go" />
        </ContentTemplate>
    </asp:UpdatePanel>

    This text is outside of the update panel and
    it acts the same as well.

    </form>
</body>
</html>

SELECTION CRITERIA

1. The component must generate/manage reports in memory rather than requiring a physical file be created. There’s no need for physical file creation and it’s best to avoid it if necessary. Simply, it eliminates the need for additional folder permissions and file cleanup.

2. The component must intelligently and inherently handle page breaks. In other words, tables, images and text positioning will be based on available page space. If appropriate, content will wrap or flow from page to page. Additionally, the ability to repeat table headers would be a plus.

3. The component must work for both web and winforms development.

4. The component must produced reports of various page size and orientation. All I need here is the ability to print in portrait or landscape.

5. The component must be inexpensive — if not free — with unlimited developer seats and unlimited number of distributions. This is because I am a cheapskate.

6. The component must have ample examples/templates must be easily available. Documentation is a nice-to-have.

7. It would be nice if the component were production-ready with a proven track record.

8. It would be nice if the component included a designer since a design view can really speed up, umm, design time.

CANDIDATES

Due to my cost requirement (read limitation), I spent most of my time evaluating open source solutions including iTextSharp, SharpPDF, Report.NET and NFop.

iTextSharp is a port to C# of the Java iText library for generating PDF files. Of all the open source options, I was most impressed with iTextSharp. It is stable and actively being developed (version 3.1.7 was released on 11/25) and it comes along with tons of documentation/samples.

Unfortunately, as best as I can tell, iTextSharp requires a physical file be generated. Essentially, a Document object is created and then the iTextSharp PdfWriter listens to the document and directs a PDF-stream to a physical file. The PdfWriter will GetInstance() of a in-memory filestream without throwing an exception, however, the resulting PDF won’t render. Perhaps it’s a shortcoming in my code, but I doubt it. My guess is if the component does work with memory streams, examples and documentation would be available. Additionally, iTextSharp doesn’t gracefully handle page breaks and content wrapping. For these two reasons, I didn’t go with iTextSharp.

UPDATE: Per a comment from Bruno Lowagie, it appears I was mistaken. One can generate a PDF in memory using iTextSharp. Bruno references his book for more information in his comment.

I didn’t spend as much time reviewing SharpPDF, Report.NET and NFop. This was primarily due to lack of documentation/examples to help with my evaluation. SharpPDF, an open-source PDF generator written entirely in C#, looks promising (it handles flowing paragraphs and tables from page to page) but I believe the effort has been somewhat abandoned since its last released was back in February 2005. In conjunction with this, I couldn’t come up with any samples or documentation (other than NDoc) and I was lead to believe SharpPDF handles PDF generation similarly to iTextSharp (reference to a physical file). In the long run, this SharpPDF probably wouldn’t have met my needs, but I would like to play with it a little.

AND THE WINNER IS…

Siberix Report Writer 6.0

In the end, I opted to go with Siberix Report Writer 6.0 which met every requirement with the exception of having a designer.

For a few days now, I’ve been working with the trial version (which is conveniently full-featured and simply applies a watermark to the generated report.) I was able to put a reporting framework in place relatively quickly. Of course, my reporting background definitely helped, but I was also able to find a working example for nearly everything I’ve needed to accomplish in the extensive set of Siberix samples.

On this note, if I were to make one request of Siberix, it would be for more samples which focus on report layout. They do provide one sample project which produces an invoice-like report, but since there is no designer, it would be great if more samples provided “templated” layouts.

The component isn’t free, but it’s close. It’s $299 (and the source can be purchased for $2000.) I haven’t had any issues with the product yet. In my opinion, it’s definitely worth the investment.

RESOURCE

I was lucky enough to come across a fine PDF Component for .NET write-up in the How-To-Select Guides series early on in the evaluation period. It provides a very extensive list of “everything PDF” from viewers to editors to print drivers. It’s worth a look.

     Data Source=myServer;
     Initial Catalog=myDB;
     User Id=myUsername;
     Password=myPassword;
     Application Name=myApp;

Consider this example:  There are multiple .NET applications running on a single web server.  Each application shares a common SQL Server Server which is suddenly performing very poorly.   You are tasked with determine which of the applications is causing havoc.  You launch SQL Profiler and run a trace.  Since you have included the optional parameter in your connection string, you may now filter the application specific queries and troubleshoot the problem far more effectively.  If you hadn’t specified the application name, you would have some work ahead of you.  In this case, all of the queries would have had a generic app name, .NET sqlClient Data Provider, and that isn’t very helpful, is it?  

Do yourself a favor and be sure to add this practice to your coding standards…