If you stored the day of the week in numerical format (1 = Sunday, 7 = Saturday) then sorting can be accomplished via a simple order by clause.

1
2
3
4
5
6

SELECT
     *
FROM
     classes
ORDER BY
     day ASC

However, if you have saved the day of the week in textual format then things become a little trickier.

The problem is “order by” on a textual value sorts alphanumerically from a-z and has no comprehension about the order of weekdays. In this situation Thursday comes before Wednesday, Saturday before Tuesday, etc. To get around this we need to let the SQL query know what order to handle the weekdays in.

Transact-SQL’s CASE expression is perfect for this task. All we have to do is assess the day string in the “order by” clause and return a numerical value depending on the result of the expression.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

SELECT
     *
FROM
     classes
ORDER BY 
     CASE
          WHEN Day = 'Sunday' THEN 1
          WHEN Day = 'Monday' THEN 2
          WHEN Day = 'Tuesday' THEN 3
          WHEN Day = 'Wednesday' THEN 4
          WHEN Day = 'Thursday' THEN 5
          WHEN Day = 'Friday' THEN 6
          WHEN Day = 'Saturday' THEN 7
     END ASC

The resultset will now be sorted based on the textual “day of the week” field, exactly as it would be if the field held a numeric value.

For more details on Transact-SQL’s CASE expression see http://msdn.microsoft.com/en-us/library/ms181765.aspx.

Simply hold ctrl, alt and press 3 to get a nice little hash character onto your screen. Simples!

For example, the literal value 5.3 will, by default, be assumed to be a double. As such, the following

1

float result = 5.3 / 12.4;

will result in the exception

Cannot implicitly convert type ‘double’ to ‘float’. An explicit conversion exists (are you missing a cast?)

You could cast the value but that would create an unneccessary overhead and result in messy code.

1
2
3

float result = (float)5.3 / (float)12.4; 
or
float result = (float)(5.3 / 12.4);

The most suitable way to approach this is to advise the compiler on the literal type. You do this by applying a suffix to your literal.

1

float result = 5.3f / 12.4f;

This can also be used when passing a literal as a parameter in a method signature.

1

MyObject.MyMethod(12.5m);

A table of the most common literal type declarations can be seen below.

1
2
3
4
5
6

var x = 1m;  // decimal
var x = 1f;  // float
var x = 1d;  // double
var x = 1l;  // long
var x = 1u;  // uint
var x = 1ul; // ulong

Tools > Options > Privacy > Show Cookies > Remove All Cookies

Previously I posted the article Creating a simple RSS feed using ASP.NET MVC which demonstrated how to create an RSS feed in a quick, easy way. Here, I will show you how to create an RssResult to be returned directly from your controller. This offers a much more scalable, reusable approach that is flexible enough to handle any data that you wish to serve and is designed specifically for addition to your ASP.NET MVC stack.

The RssResult must be capable of taking any data and knowing how to render an RSS item from it (i.e. news, events, posts, comments, reviews etc). So before we create the RssResult we need to abstract the structure of an RSS item. We do this by creating an interface abstraction to accommodate this. Any object that is to be served can implement this interface allowing the RssResult to work with it.

1
2
3
4
5
6
7
8
9

namespace System
{
    public interface IRss
    {
        string Title { get; }
        string Description { get; }
        string Link { get; }
    }
}

The standard return type of a controller’s methods is the abstract type ActionResult. In most cases the actual returned object will be of type ViewResult, which will look for a view to use when rendering your model to the response stream. Here, our RssResult will inherit from ActionResult, just as ViewResult does, but will internally render its own XML output and alter the response’s content-type header to xml, avoiding any view files or extra work in the controller. Using dependency injection the RssResult will not be instantiable without being supplied with the data it has to serve, which will be a List. It will also accept a title and description for the feed.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

using System;
using System.Collections.Generic;
using System.Xml;
 
namespace System.Web.Mvc
{
    public class RssResult : ActionResult
    {
 
        private List<IRss> _items;
        private string _title;
        private string _description;
 
        /// <summary>
        /// Initialises the RssResult
        /// </summary>
        /// <param name="items">The items to be added to the rss feed.</param>
        /// <param name="title">The title of the rss feed.</param>
        /// <param name="description">A short description about the rss feed.</param>
        public RssResult(IEnumerable<IRss> items, string title, string description)
        {
            _items = new List<IRss>(items);
            _title = title;
            _description = description;
        }
 
        public override void ExecuteResult(ControllerContext context)
        {
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.NewLineHandling = NewLineHandling.Entitize;
 
            context.HttpContext.Response.ContentType = "text/xml";
            using (XmlWriter _writer = XmlWriter.Create(context.HttpContext.Response.OutputStream, settings))
            {
 
                // Begin structure
                _writer.WriteStartElement("rss");
                _writer.WriteAttributeString("version", "2.0");
                _writer.WriteStartElement("channel");
 
                _writer.WriteElementString("title", _title);
                _writer.WriteElementString("description", _description);
                _writer.WriteElementString("link", context.HttpContext.Request.Url.GetLeftPart(UriPartial.Authority));
 
                // Individual items
                _items.ForEach(x =>
                {
                    _writer.WriteStartElement("item");
                    _writer.WriteElementString("title", x.Title);
                    _writer.WriteElementString("description", x.Description);
                    _writer.WriteElementString("link", context.HttpContext.Request.Url.GetLeftPart(UriPartial.Authority) + x.Link);
                    _writer.WriteEndElement();
                });
 
                // End structure
                _writer.WriteEndElement();
                _writer.WriteEndElement();
            }            
        }
 
    }
}

As you can see above, the RssResult itself is pretty simple. It takes the collection of IRss items in it’s constructor. By inheriting the abstract type ActionResult it must override ExecuteResult which is called by the framework when it is returned from the controller, which you can see an example of below. One thing to notice in the following code snippet is that the original list of items must be cast to a list of IRss. This is due to the limitations of covariance and contravariance on generics in the C# language. Future versions may support this so that casting will not be required.

1
2
3
4
5

public ActionResult Feed()
        {
            IEnumerable<IRss> news = new NewsService().GetByLatest().Cast<IRss>();
            return new RssResult(news, "William Duffy - Glasgow Based ASP.NET Web Developer", "The latest news on ASP.NET, C# and ASP.NET MVC ");
        }

I’m a BIG believer in developing my own reusable code libraries and frameworks as I work, so I decided to create a reusable ToString() extension method on the boolean type to cater for this scenario, and thought I’d share it…cause that’s the kind of guy I am!

It’s important to note that I put the extension method within the System namespace. This allows the extension to be available anywhere in your application. Also, I use a regular expression in the implementation, so be sure to import the RegularExpressions namespace.

1
2
3
4
5

using System.Text.RegularExpressions;
 
namespace System
{
}

The first requirement is a simple enum that allows programmatic access to the most common conversions. This lets programmers avoid typing string values if possible, reducing spelling mistakes (which is always a good thing when it comes to us programmers). The enum represents the output in camel case with values in the format TrueFalse.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

///<summary>
///Defines a textual boolean value
///</summary>
///<remarks></remarks>
public enum BooleanText
{
    AcceptedDeclined,
    ActiveInactive,
    CheckedUnchecked,
    CorrectIncorrent,
    EnabledDisabled,
    OnOff,
    YesNo
}

Next we create a static class to expose our extension methods.

1
2
3

public static class BooleanExtensions
{
}

The first ToString() extension method accepts a single parameter of type BooleanText. It runs a super simple regular expression to parse the BooleanText value into two seperate true/false values based on the camel case formatting and then makes a call to the second extension method with the results.

1
2
3
4
5
6
7
8
9
10
11

/// <summary>
/// Assesses a boolean value and returns a textual value
/// </summary>
/// <param name="text">The textual value to be returned</param>
/// <returns>A textual representation of the boolean value</returns>
/// <remarks></remarks>
public static string ToString(this bool value, BooleanText text)
{
    MatchCollection matches = Regex.Matches(text.ToString(), "[A-Z][a-z]+");
    return value.ToString(matches[0].Value, matches[1].Value);
}

The second ToString() extension method accepts two parameters of type System.String. This caters for programmers when the common values in BooleanText are not suitable.

1
2
3
4
5
6
7
8
9
10
11

/// <summary>
/// Assesses a boolean value and returns a specified word in respect to true or false
/// </summary>
/// <param name="trueValue">The textual value to be returned if the current boolean is true</param>
/// <param name="falseValue">The textual value to be returned if the current boolean is false</param>
/// <returns>A string representation of the current boolean value</returns>
/// <remarks></remarks>
public static string ToString(this bool value, string trueValue, string falseValue)
{
    return (value) ? trueValue : falseValue;
}

It’s now simply a case of calling ToString() on your boolean value and getting the output you need straight from the type, rather than writing if/else logic into your code.

1
2

bool value = true;
lblValue.Text = value.ToString(BooleanWord.EnabledDisabled);

1

<%= Html.ActionLink("My Link", "MyLink", null, new { class = "test" }) %>

However, a problem arises with the class property, because class is a reserved word the compiler will throw the following error…

Compiler Error Message: CS1513: } expected

Fortunately the solution is simple. Prepend the reserved class keyword with an @ character. This lets the compiler know that you want to use the word class as a property within it’s currently applied context.

1

<%= Html.ActionLink("My Link", "MyLink", null, new { @class = "test" }) %>

For the demonstrations below I will be using a generic List<News>. News is a simple class with common news properties, we will be using Title, Description and Url. Although you can change the view to handle your own model easily enough.

Create a view named Feed, as you would normally for an HTML view. However, in this case change the ContentType property to “text/xml”. Sample code is listed below. Notice the <?xml tag is butted up against the page declaration. This is necessary because an xml document’s first character must be the beginning of the doctype declaration.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 
<%@ Page Language="C#" ="text/xml" Inherits="System.Web.Mvc.ViewPage<IEnumerable<Domain.Model.News>>" %><?xml version="1.0"?>
<rss version="2.0">
  <channel>
    <title>William Duffy's News</title>
    <link>http://www.wduffy.co.uk</link>
    <description>The latest news and stuff from the exciting life of William Duffy</description>
    <% foreach (var news in Model) { %>
    <item>
      <title><%= news.Title %></title>
      <link>http://www.wduffy.co.uk/News/Details/<%= news.Url %></link>
      <description><%= news.Description %></description>
    </item>
    <% } %>
  </channel>
</rss>

In your controller, pass the IEnumerable collection of items that are to be represented in the rss document to the view.

 
public ActionResult Feed()
{
    NewsCollection news = new NewsService().GetByLatest();
    return View(news);
}

And that’s it. You can now request your rss document at http://www.yourdomain.com/Controller/Feed.

However I wanted to keep the default route mapping “{controller}/{action}/{id}” to handle generic formats along with this top level action route. The problem with allowing both these situations is the routes to handle both will always match each other. Whichever comes first will try to handle the routing for either.

For example a request for url /Admin would be happily matched by the route {action} or {controller}/{action}. In this case, if we wanted the /Admin url to be handled by the AdminController, the {action} route would match the request and try to route it to RootController’s Admin action; which of course does not exists. If we swapped the order of these routes in the global.asax file then /Admin would be matched properly and routed to AdminController’s Index action. However, now a requested for url /Contact would result in the generic route assuming /Contact is a controller and routing the request to ContactController’s Index method. Which does not exist because Contact is in-fact an action in RootController.

1
2
3
4
5
6
7
8
9
10
11

routes.MapRoute(
    "Root",
    "{action}",
    new { controller = "Root", action = "Index" }
);
 
routes.MapRoute(
    "Generic",
    "{controller}/{action}/{id}",
    new { controller = "Generic", action = "Index", id = "" }
);

The solution was to create a custom constraint on the root route. This constraint would check to see if a controller exists that matches the {action} parameter’s value. If it does then we know that a controller has been requested and that the root route should not handle it. This will result in the next route in the table (the generic route) being assessed to handle the request.

In order to implement this you simply create a new custom contraint object and inherit IRouteContraint. In the constructor of the custom contraint assess the assembly for all types that inherit from Controller and create a dictionary object to keep hold of them. Then, every time the route engine assesses the request by calling Match check the action that has been requested and see if there is a specific controller that has the same name.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

using System.Collections.Generic;
using System.Linq;
using System.Web.Routing;
using System.Reflection;
 
namespace System.Web.Mvc
{
    public class IsRootActionConstraint : IRouteConstraint
    {
        private Dictionary<string, Type> _controllers;
 
        public IsRootActionConstraint()
        {
            _controllers = Assembly
                                .GetCallingAssembly()
                                .GetTypes()
                                .Where(type => type.IsSubclassOf(typeof(Controller)))
                                .ToDictionary(key => key.Name.Replace("Controller", ""));
        }
 
        #region IRouteConstraint Members
 
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
        {
            return !_controllers.Keys.Contains(values["action"] as string);
        }
 
        #endregion
    }
}

Now all that is left to do is pass a new instance of the custom constraint in the routing table.

1
2
3
4
5
6
7
8
9
10
11
12

routes.MapRoute(
    "Root",                                                 
    "{action}",
    new { controller = "Root", action = "Index" }
    new { IsRootAction = new IsRootActionConstraint() }  // Route Constraint
);
 
routes.MapRoute(
    "Generic",
    "{controller}/{action}/{id}",
    new { controller = "Generic", action = "Index", id = "" }
);

You will now be able to use much neater root url’s and still have the advantage of a generic route in your routing table

One common method of doing this is to return XML which represents the object you wish to return. You then map the values in the XML document to your JavaScript object (or parse the XML document manually) at which point you can start working with it as normal.

However, a much easier option is to return JSON (JavaScript Object Notation). Using a framework such as jQuery you can simply retrieve the JSON and have concrete JavaScript object ready for manipulation.

This is highly advantageous when you are performing AJAX operations. For example, imagine you have a server-side postcode query system that returns latitude/longitude values for a submitted postcode. After the postcode is queried on the server a Location object is created which holds the latitude/longitude values to return to the client. This object would look like the following…

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Location
{
    public Location(string postcode, double latitude, double longitude)
    {
        Postcode = postcode;
        Latitude = latitude;
        Longitude = longitude;
    }
 
    public string Postcode { get; set; }
    public double Latitude { get; set; }
    public double Longitude { get; set; }
}

To allow the client to receive the Location object we create an HttpHandler. In a production environment this HttpHandler would query your database for the submitted postcode. However in the example below we will use a mock object to demonstrate JSON serialization in action. (Serialization is simply a means of representing an object in state. In this case the state will be text for transmission over the http protocol.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System;
using System.Web;
using System.Web.Script.Serialization;
 
public class LocationHandler : IHttpHandler {
 
    public void ProcessRequest (HttpContext context) {
 
        string postcode = context.Request.QueryString["postcode"];
 
        // This is where you would query your database
        // i.e. Assess postcode for valid data
        // i.e  Create postcode database parameter @postcode
        // i.e. SELECT latitude, longitude FROM tblGeocodes WHERE postcode = @postcode;"
        // However for this demo we will create a mock object
 
        double rnd = new Random().NextDouble();
        Location loc = new Location(postcode, 55.95254 * rnd, -4.767455 * rnd);
 
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        context.Response.Write(serializer.Serialize(loc));
        context.Response.ContentType = "application/json";
 
    }
 
    public bool IsReusable {
        get {
            return false;
        }
    }
 
}

The code above creates the Location object. It then creates a JavaScriptSerializer object which it uses to serialize the Location object to the response stream. The result is a JSON representation of the Location object that can be sent to the client where JavaScript can recreate it. The JSON looks as follows

{"Postcode":"pa16 8ng","Latitude":14.566054759251575,"Longitude":-1.24110559757015}

Note: You will need to ensure that you have a reference to the System.Web.Extensions dll. If you are using ASP.NET 3.5 this is already installed and available. If you are using ASP.NET 2.0 you will need to download ASP.NET AJAX.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>JSON Location</title>
    <script src="jquery-1.3.2.min.js" type="text/javascript"></script>
    <script type="text/javascript">
        $().ready(function() {
            $('#<%=txtPostcode.ClientID%>').keyup(function() {
                $.getJSON("LocationHandler.ashx", { postcode: this.value }, function(location) {                   
                    $(".postcode").text(location.Postcode);
                    $(".latitude").text(location.Latitude);
                    $(".longitude").text(location.Longitude);
                });
            });
        });
    </script>
</head>
<body>
    <form id="form1" runat="server">
 
    Get location for postcode: 
    <asp:TextBox ID="txtPostcode" MaxLength="8" runat="server" /><br /><br />
 
    Postcode: <span class="postcode"></span><br />
    Latitude: <span class="latitude"></span><br />
    Longitude: <span class="longitude"></span>
 
    </form>
</body>
</html>

I am using jQuery to perform the AJAX request, but you can use whatever javascript method/framework you prefer.

IMPORTANT

Retreiveing and working with JSON is perfectly safe to do when you know and trust the source. However, if you do not know the source that is serving the JSON this can be a potentially dangerous call. So in cases where you are not in full control or fully trust the JSON provider you should seek a different solution.