I needed the SMTP service to automatically start running on reboot, and the solution was simple.

The SMTP service’s startup type is, by default, set to Manual. To alter this navigate to Start -> Administrative Tools -> Services and find the Simple Mail Transfer Protocol (SMTP) service.

Right click on the service and choose properties. A modal window should appear where you can change the startup type from Manual to Automatic.

The web application allowed clients to upload excel spreadsheets that are read by an ADO DataAdapter and written to Sql Server. The old server was running Windows Server 2003, the new server was running Windows Server 2008. Everything worked fine on the old 2003 server, however the new 2008 server just wouldn’t play nice. On uploading an excel spreadsheet the following exception was being thrown

The ‘Microsoft.Jet.OLEDB.4.0′ provider is not registered on the local machine.

Thankfully the solution to the problem was a simple one. IIS on Windows Server 2008 was running its application pool in 64 bit mode. There are no 64 bit Jet drivers. Simply changing the application pool to run in 32 bit mode enables support for the 32 bit Jet drivers.

To do this right click on the target application pool in IIS, select Advanced Settings and change Enable 32-Bit Applications to True.

If you want to check that you have the latest version of the Jet drivers goto c:\Windows\SysWOW64, right click on the Msjet40.dll file, select the details tab and view the version number. At the time of writing the latest version was 4.0.9704.0. You can view more details on this process at http://support.microsoft.com/kb/239114

The Application_Error event within the global.asax is the perfect place for this, but there are a few issues to consider when used in an MVC project.

1. Server.Transfer is not available to serve an error message as it requires a physical file to serve. Your MVC project more than likely doesn’t have one of theses as it uses routes, controllers and views. We need to find a workaround for this in order to return suitable response headers.
2. Reponse.Redirect is not suitable as ’500: Internal Server Error’ and ’404: Not Found’ pages should serve a suitable response header, not a 301 redirect.
3. Response.Clear() should be called to ensure that any content written to the response stream before the error occurred is removed.
4. Server.ClearError() must be called to stop ASP.NET from serving the yellow screen of death.

With these points in mind the following steps can be coded into the Application_Error event for error handling and logging.

1. Get the last error raised.
2. Get the error code to respond with.
3. Log the error (I’m ignoring 404′s).
4. Clear the response stream.
5. Clear the server error.
6. Render the error handling controller without a redirect.

Here is the Application_Error code…

void Application_Error(object sender, EventArgs e)
{
        var error = Server.GetLastError();
        var code = (error is HttpException) ? (error as HttpException).GetHttpCode() : 500;
 
        if (code != 404)
        {
                // Generate email with error details and send to administrator
                // I'm using RazorMail which can be downloaded from the Nuget Gallery
                // I also have an extension method on type Exception that creates a string representation
                var email = new RazorMailMessage("Website Error");
                email.To.Add("errors@wduffy.co.uk");
                email.Templates.Add(error.GetAsHtml(new HttpRequestWrapper(Request)));
                Kernel.Get<IRazorMailSender>().Send(email);
        }
 
        Response.Clear();
        Server.ClearError();
 
        string path = Request.Path;
        Context.RewritePath(string.Format("~/Errors/Http{0}", code), false);
        IHttpHandler httpHandler = new MvcHttpHandler();
        httpHandler.ProcessRequest(Context);
        Context.RewritePath(path, false);
}

And here is the ErrorsController code. Notice each action sets the response status error code before rendering the view. Be careful with this controller as any errors will result in an infinite loop between itself and the Application_Error event!

public class ErrorsController : Controller
{
 
        [HttpGet]
        public ActionResult Http404(string source)
        {
                Response.StatusCode = 404;
                return View();
        }
 
        [HttpGet]
        public ActionResult Http500(string source)
        {
                Response.StatusCode = 500;
                return View();
        }
 
}

In order to reset the admin password I run the following simple SQL query against the WordPress database using MySql query browser.

Replace your_database and your_password as required.

UPDATE
	your_database.wp_users
SET
	user_pass = MD5('your_password')
WHERE
	user_login = 'admin';

Note: You can of course use the snippet above for any user, but if it’s not the admin password requiring a reset perhaps using the login area will be easier.

The following code snippet allows you to do just this. Simply create a generic handler somewhere accessible on your website to call when you need to clear the cache. For example www.yoursite.com/clearcache.ashx.

using System;
using System.Web;
using System.Collections;
 
public class ClearCache : IHttpHandler
{
    public bool IsReusable
    {
        get { return true; }
    }
 
    public void ProcessRequest(HttpContext context)
    {
        foreach (DictionaryEntry item in context.Cache)
            context.Cache.Remove(item.Key as string);
 
        context.Response.ContentType = "text/html";
        context.Response.Write("Cache cleared.");
    }
}

However, it quickly becomes tiresome writing the logic to work out which rows are odd/even and change css classes on every table/project, not to mention it breaks the DRY principle. A further issue arises from the MVC pattern’s recommendation that views should be dumb and have low cyclomatic complexity.

To get around both these issues, and in the process gain an abstracted, reusable method of alternating the row colours we can create an extension method. This extension method, when implemented against the IList interface, allows for its use on any concrete collection which implements that interface.

namespace System.Collections
{
  public static class IListExtensions
   {
 
    public static string GetRowClass(this IList list, object item, string evenClass, string oddClass = "")
     {
      int index = list.IndexOf(item);
      return index % 2 == 0 ? evenClass : oddClass;
     }
 
   }
}

To alternate row colours in your view it’s simply a case of calling the extension method and passing in the relevant classes for odd/even rows.

<table class="formattedTable" cellspacing="0">
 <tr>
  <th>Name</th>
  <th>Business</th>
  <th>Email</th>
 </tr>
 <% foreach (var c in Model.Contacts) { %>
 <tr class="<%: Model.Contacts.GetRowClass(c, "evenRow", "oddRow") %>">
  <td><%: c.Fullname %></td>
  <td><%: c.Business %></td>
  <td><%: c.Email)%></td>
 </tr>
 <% } %>
</table>

I have put the extension method into the System.Collection namespace so that I only have to reference my extension method library in the project to access it, however if you are uncomfortable with this you can easily put it into your own namespace and import it manually.

Also, notice that I am using C# 4′s optional parameters on the oddClass parameter. A lot of times I only style one row and leave the other transparent so this allows for slightly neater view markup. If you aren’t using C# 4 you can simply overload the extension method.

For example, if you were consuming an RSS feed which had description values greater than 500 characters in length, but you only wanted to display the first 50 characters before leading the user through to the full post.

The solution is XPath functions. Much like any general level scripting language such as VBScript or PHP, XPath makes available a range of functions to help you achieve basic type manipulation and querying.

Lets elaborate on the RSS example. Imagine you were consuming a feed which looked similar to the following (trimmed for simplication).

<?xml version="1.0" encoding="UTF-8"?>
<rss>
<channel>
...
<item>
<title>Modifing XML values in XSLT documents</title>
<link>http://feedproxy.google.com/~r/wduffy/~3/WkFIKaXB1lI/</link>
<description><![CDATA[Ever wondered how to perform manipulations of XML values in an XSLT document?
For example, if you were consuming an RSS feed which had description values greater than 500 characters in length, but you only wanted to display the first 50 characters before leading the user through to the full post.
The solution is XPath functions. Much [...]]]></description>
</item>
...
</channel>
</rss>

You wish to render a short preview of the latest blog post in a format similar to the following example, perhaps on a website’s “latest blog posts” widget.

<strong>Modifing XML values in XSLT documents</strong><br />
Ever wondered how to perform manipulations of XML...<br />
<a href="http://feedproxy.google.com/~r/wduffy/~3/WkFIKaXB1lI/">Read the full post!</a>

The XSLT document would be formatted as below. Notice the call to substring() when requesting the value of the xml document’s description field. This function extracts a new value from the XML documents description value starting at position 0, and finishing at position 50.

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:template match="/">
  <xsl:for-each select="/rss/channel/item">
   <xsl:if test="position() &lt;= 1">
 
       <strong><xsl:value-of select="title" /></strong><br />
       <xsl:value-of select="substring(description, 0, 50)" disable-output-escaping="yes" />...<br />
 
       <a>
        <xsl:attribute name="href"><xsl:value-of select="link"/></xsl:attribute>
        Read the full story
       </a>
 
   </xsl:if>
  </xsl:for-each>
 </xsl:template>
</xsl:stylesheet>

Having this level of control over the transformation process allows for a huge range of possibilities and doesn’t only apply to basic string manipulation. Functions exist for date types, numeric types, boolean types and nodes. For more details on exactly what is available check out this excellent overview of XPath, XQuery, and XSLT Functions on W3 Schools.

The solutions is to create a Google Goal with a fake url and manually call this on the user’s interaction with the element leading them to the resource. For example, if I wanted to track a user clicking the link <a href=”mailto:your@email.com”>Contact Me</a> to engage in dialogue, I would create a goal whose url is /G1/Email-Enquiry. If I also wanted to track a user clicking <a href=”/downloads/my-brochure.pdf”>Download My Brochure</a> to get more details, I would create a goal whose url is /G2/Brochure-Download. Neither of these urls exist.

To set up a goal go to your Google Analytics account > click Edit next to the profile you wish to add the Google Goal to > click Add Goal in the goals area.

IMPORTANT: Remember to include your Google Analytics tracking code on your page before continuing if you have not already done so! It must be placed at the top of your page above all manual calls to the Google API for everything to work.

Once your goals are setup you simply need to request your fake url when the user interacts with your goal. Fortunately _gaq.push() is already setup to easily handle this. _gaq.push() is the Google API method used to send tracking information to Google Analytics, it will normally look like the following.

var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2305701-34']);
_gaq.push(['_trackPageview']);

With this method available we can easily track user interaction on an element by passing our custom goal urls in an onclick event handler. See the following demonstration as an example.

 
   <a href="mailto:your@email.com" onclick="_gaq.push(['_trackPageview', '/G1/Email-Enquiry']);">Contact Me</a>
 
   <a href="/downloads/my-brochure.pdf" onclick="_gaq.push(['_trackPageview', '/G2/Brochure-Download']);">Download My Brochure</a>

Everything should be working great at this point. However, this implementation can become difficult to maintain/scale when multiple interactions are regarded as the same goal. For example, if you have tens, hundreds, even thousands of those links scattered throughout your site you will need to manually attach the Google Goal to every one of them.

To work around this manual process we can use jQuery selectors to assess the dom when the page is ready, attaching the call to Google Analytics on each element’s click event. The selectors below find all a elements whose href attribute contains the specified value.

<script type="text/javascript" src="/js/jquery-1.4.1.min.js"></script> // Download your copy at jQuery.com
<script type="text/javascript">
    $(function() { // Set Google Goals
        $("a[href*=your@email.com]").click(function(){_gaq.push(['_trackPageview', '/G1/Email-Enquiry']);});
        $("a[href*=my-brochure.pdf]").click(function(){_gaq.push(['_trackPageview', '/G2/Brochure-Download']);});
    });
</script>

If you have different requirements for your selectors or for more information on jQuery selectors check out the jQuery documentation.

I’ve put the extension directly into the System namespace, but you can put it somewhere else if you prefer. Now if only we could get this into the frameworks inbuilt date formatting strings, that would be cool!

 
namespace System
{
        ///<summary>
        ///Returns the ordinal suffix for the day of the month represented by this instance
        ///</summary>
        ///<returns></returns>
        public static string OrdinalSuffix(this DateTime datetime)
        {
            int day = datetime.Day;
 
            if (day % 100 >= 11 && day % 100 <= 13)
                return String.Concat(day, "th");
 
            switch (day % 10)
            {
                case 1:
                    return String.Concat(day, "st");
                case 2:
                    return String.Concat(day, "nd");
                case 3:
                    return String.Concat(day, "rd");
                default:
                    return String.Concat(day, "th");
            }
        }
}

The HTML.PasswordFor<> method will render a password input to mask keystrokes on the browser but will not populate the value using the model. For most scenarios this is fine however there are occasions this functionality can be counter productive.

For example, a logged in user may be given the opportunity to update their password. A suitable implementation of this would include three fields in the process.

1. Current Password
2. New Password
3. Confirm New Password

All these fields will be keystroke masked password fields. When the post to your action occurs the model will be validated to ensure the following restrictions are met

1. Current Password is supplied and is correct
2. New password is supplied and is within acceptable criteria
3. Confirm New Password matches New Password exactly

Any of these criteria can fail, at which point the action will return its view with suitable validation errors. The problem exists at this point as the password field will not be repopulated with the last entered value, instead being reset to blank. Fortunately the solution, although not instantly obvious, is very easy. Simply populate the value manually using Html.PasswordFor’s htmlAttributes parameter and your model.

Html.PasswordFor(x => x.CurrentPassword, new { value = Model.CurrentPassword })

The user can now continue to enter their details from the point that validation failed.

Important Note. Do not pass your original domain model to the view model if you are going to use this method. If you do, the password will always be pre-populated. The view model should have it’s own properties to handle the three password entries and be empty by default.