C#

DataSprings Blog Post

Joe Mayo — Tue, 07 Jun 2011 00:32:14 GMT

Here's a blog post by DataSprings on how to use LINQ to Twitter: http://bit.ly/jjmLZY. It demonstrates how to authenticate with OAuth and how to use several of the APIs.

Joe

Displaying Search Results With LINQ to Twitter and ASP.NET MVC

Joe Mayo — Thu, 28 Apr 2011 14:27:15 GMT

Sometimes, the way that LINQ to Twitter materializes queries into entities isn’t immediately clear. It’s easy to get confused until you see the patterns or make a correlation between the Twitter API results and their representations as LINQ to Twitter entities. In this post, I’ll explain some of the logic behind the design of LINQ to Twitter entities and demonstrate an example of one of the more oddly designed entity types, Search.

Note: They'll be talking about MVC3 during multiple sessions at Tech-Ed.

Basic Concepts

When designing LINQ to Twitter entities, the fundamental concepts were to have as much parity with Twitter API results as possible and do the minimum amount of customization required to obtain materialized results. The reasoning weighed heavily towards the ability to match results to the official Twitter API documentation, quicker development, and easier debugging.

The similarities between class entities and Twitter API XML results are in the areas of object structure and identifiers. The object structure matches the XML queries as close as possible and identifier names are close to XML element names. Occasionally, I’ve diverged from Twitter API formats, especially in naming conventions, where I felt the Twitter API element names were much less meaningful.

Note: A common FAQ is the confusion with ID, UserID, and ScreenName on both the User entity and in the User.Identifier. The fields on the User entity are input (sent to Twitter), but the User.Identifier fields are output (returned from Twitter). This design decision was made so that you can see what values were used to compose the query, as opposed to what Twitter returned. A common scenario is for queries to be made without ID, UserID, or ScreenName because the query is being made on behalf of the authenticated user. This means that ID, UserID, and ScreenName are blank on the entity. As always, you would read the results of a materialized query from User.Identifier.

The Twitter API results format preference in LINQ to Twitter is XML. This decision comes from the fact that LINQ to Twitter was originally conceived as the example in my book, LINQ Programming/McGraw Hill, of how to build a LINQ provider. In that case, it was more instructive to use LINQ to XML to translate Twitter API results into objects. Some Twitter APIs don’t support XML and only JSON or ATOM is an option. At the time I wrote the Search API, raw XML wasn’t available, but ATOM was. Being a specialized XML format, I chose ATOM for Search.

Considering the pattern of designing entities as close to the Twitter API results as possible, a legacy of choosing XML first, and Search supporting ATOM, the Search entity models the Twitter API results in ATOM format. Before diving too far into the example, the next section introduces the technology to be used with a couple architectural hints.

Technology/Architecture

A lot of my current work is done with ASP.NET MVC and feedback indicates that this is a very popular Web development option among other developers. I know, I just set myself up for trolls to flame me for my technology choice. Perhaps I should qualify my choice by acknowledging that ASP.NET Web Forms is still a live and viable technology that a lot of people love and like. Anyway, the following example will be in ASP.NET MVC3 with the Razor template engine.

I’ll be moving LINQ to Twitter queries into a Repository. I could have used LINQ to Twitter in the controllers, but that would have been lazy (I’ll be lazy elsewhere this time). I’ll translate the Search entities into a custom ViewModel. Hopefully, this will provide a useful example of one option available (there are more) for moving data around your application.

You can get started by creating a new MVC 3 project. I won’t go into all the details of getting started because there are tons of introductory blog posts and articles across the Web, showing how to start an MVC project. Let’s start with the repository.

Building a Repository

A common practice in application development is to separate concerns so your application is easier to build and maintain. One pattern for separating data management from the rest of the application is called Repository, which this application uses. Repositories are often used to abstract relational database operations, but are also used for other types of data such as text file, Excel, Web Service, or XML (and more). For the purposes of this application, Twitter is a data source. We’ll build the repository to return LINQ to Twitter Search entities, materialized from a query to the Twitter API. Here’s the repository:

using LinqToTwitter;
using System.Collections.Generic;
using System.Linq;

namespace TwitterSearchMVC.Models
{
    public class SearchRepository
    {
        public List<AtomEntry> Search(string tag)
        {
            using (var twitterCtx = new TwitterContext())
            {
                var searchResults =
                    (from search in twitterCtx.Search
                     where search.Type == SearchType.Search &&
                           search.Hashtag == tag
                     select search)
                    .SingleOrDefault();

                return searchResults.Entries;
            }
        }
    }
}

The code above is just a class, SearchRepository, with a single method, Search, for performing the search. If you needed more specialized operations with search, you could add more methods, but this is all we need for this demo. The query is a typical search query, using the LINQ to Twitter Type idiom and filtering via a tag. Search queries can filter by any normal or advanced criteria that Twitter offers, but the tag is all we need for the demo.

Now, you have data access code isolated in a repository. We also know that the data will be delivered in the form of a LINQ to Twitter Search entity. Next, let’s look at a similar object, the ViewModel.

Designing a ViewModel

The purpose of the ViewModel is to represent the data that will be displayed in the UI. One of the first questions you might have is “Why can’t I just bind the LINQ to Twitter Search entity to the UI?”. After all, demos from many very well-known people bind DB entities to the UI and if they do it then it must be right? Not quite; remember that those are demos in a blog post that are intentionally as short as possible or are trying to demonstrate something and proper architecture isn’t germane to the purpose of their post/article. However, when you’re writing a real-world application, these architectural details, like ViewModels, Repositories, and more become very important.

There are a few reasons why you should use ViewModels, rather than binding data objects; revolving around the shape of the data, display characteristics, and validation. What you bind to the UI should be a whole different object than what comes from the data source. First, consider that your UI can have multiple items, including a header, menu, and data display. The display of the data might be hierarchical or flat. On the other hand the objects from the data source often have a different shape. In addition to data shape, you can annotate ViewModel properties with information specific to the UI, like DisplayName. You can also specify validation rules in your ViewModel that help UI controls manage user input, such as whether a field is required, string length, or email pattern. All of these ViewModel details are associated with the UI or communicating with UI controls and don’t belong on your data object. With that in mind, please review the following SearchViewModel:

using System.ComponentModel;

namespace TwitterSearchMVC.Models
{
    public class SearchViewModel
    {
        [DisplayName("Tweet ID")]
        public string ID { get; set; }

        [DisplayName("User Name")]
        public string Source { get; set; }

        [DisplayName("Tweet Text")]
        public string Content { get; set; }
    }
}

The first thing you should notice about the SearchViewModel is that it only has a few properties, as opposed to the multitude of properties available on the Search entity. This brings up another important issue is that you don’t need to be overloading View processing resources by moving all the data around everywhere. It’s common that you’ll only be displaying a sub-set or specialization of the data returned from a repository. As I mentioned earlier, you can annotate ViewModel properties to make them work better in the UI. In this case, if you were using a 3rd party control like Telerik Grid, the DisplayName attribute would specify the column headings in the grid.

Now that we have data from the data source and a ViewModel for the UI, I’ll show you how to build a controller that translates between the two.

Constructing a Controller

In the controller, I’m going to translate from AtomEntry to SearchViewModel, and display the results. Here’s the controller:

using LinqToTwitter;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using TwitterSearchMVC.Models;

namespace LinqToTwitterSearchMvc.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            List<SearchViewModel> searchVM = PopulateSearchViewModel();
            return View(searchVM);
        }

        public List<SearchViewModel> PopulateSearchViewModel()
        {
            List<AtomEntry> searchList =
                new SearchRepository().Search("LinqToTwitter");

            var searchVM =
                (from search in searchList
                 select new SearchViewModel
                 {
                     ID = search.ID,
                     Source = search.Source,
                     Content = search.Content
                 })
                .ToList();

            return searchVM;
        }
    }
}

Notice that I used a method named PopulateSearchViewModel to get a list of ViewModel objects. The logic uses a LINQ to Objects query to project the data into a form that can be easily displayed in the view.

Now, let’s look a the view.

Designing a View

As mentioned earlier, I’m using the MVC Razor view engine. I normally use Telerik MVC Extensions, which are a free download via CodePlex.com, but this is just a demo. So, I went with List scaffolding via the View wizard (you can open the View wizard by right-clicking on View(…) in the controller code and selecting Add View). The example creates a strongly typed View using a List type scaffolding to display results, shown below:

@model IEnumerable<TwitterSearchMVC.Models.SearchViewModel>

@{
ViewBag.Title = "Index";
}

<h2>Index</h2>

<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table>
    <tr>
        <th>
            Source
        </th>
        <th>
            Content
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.Source)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.Content)
        </td>
        <td>
            @Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
            @Html.ActionLink("Details", "Details", new { id=item.ID }) |
            @Html.ActionLink("Delete", "Delete", new { id=item.ID })
        </td>
    </tr>
}

</table>

The UI will show a list of tweets that contain “LinqToTwitter”. The actual results that are assigned to the Source and Content properties of the SearchViewModel contain HTML anchor tags that you’ll need to parse out yourself. In many cases, LINQ to Twitter returns the string data given to it from Twitter. At other times, LINQ to Twitter will interpret the proper type of data, i.e. int, DateTime, etc., and set the value in the entity properly. You can also set a breakpoint in your code and examine the other fields returned from the LINQ to Twitter query for more information.

Summary

Hopefully, you now understand that there are patterns and reasons for the approach taken by LINQ to Twitter in translating Twitter API results into entities. I explained some important architectural considerations when building applications, particularly from the ASP.NET MVC perspective. You saw how to take data from LINQ to Twitter entities and translate the data into ViewModel objects for display in the UI. The result is a quick application that shows you another way to use LINQ to Twitter in an MVC application.

@JoeMayo

TechEd 2011

Joe Mayo — Sat, 16 Apr 2011 20:31:51 GMT

Now that Mix11 is over, Microsoft’s next big conference is Tech-Ed 2011, which happens May 16th through May 19th in Atlanta, GA. Each of Microsoft’s conferences have a theme; Mix is about the Web, PDC is about new and upcoming technologies, and there are many more. The focus of Tech-Ed is on current Microsoft technologies. In other words, you would go there to learn about the software that you can use today to get your work done. If you haven’t been there yet, Atlanta is a nice city and the surrounding communities are beautiful, especially in the Spring. It should be a good time.

Reviewing the list of sessions, I saw several on MVC 3, Async and Concurrent Programming, and more. What I’m going to try to do over the next month is write about the technologies being presented at Tech-Ed 2011. I already mentioned a couple that are near and dear to my geek heart, but I’ll try to hit a breadth of topics that I think are cool and maybe you will too.

@JoeMayo

JustCode Provides Reflector Alternative

Joe Mayo — Sun, 20 Mar 2011 05:04:08 GMT

If you've been a loyal Reflector user, you've probably been exposed to the debacle surrounding RedGate's decision to no longer offer a free version. Since then, the race has begun for a replacement with a provider that would stand by their promises to the community. Mono has an ongoing free alternative, which has been available for a long time. However, other vendors are stepping up to the plate, with their own offerings.

If Not Reflector, Then What?

One of these vendors is Telerik. In their recent Q1 2011 release of JustCode, Telerik offers a decompilation utility rivaling what we've become accustomed to in Reflector. Not only does Telerik offer a usable replacement, but they've (in my opinion), produced a product that integrates more naturally with visual Studio than any other product ever has. Telerik's decompilation process is so easy that the accompanying demo in this post is blindingly short (except for the presence of verbose narrative).

If you want to follow along with this demo, you'll need to have Telerik JustCode installed. If you don't have JustCode yet, you can buy it or download a trial at the Telerik Web site .

A Tall Tale; Prove It!

With JustCode, you can view code in the .NET Framework or any other 3rd party library (that isn't well obfuscated). This demo depends on LINQ to Twitter, which you can download from CodePlex.com and create a reference or install the package online as described in my previous post on NuGet. Regardless of the method, you'll have a project with a reference to LINQ to Twitter. Use a Console Project if you want to follow along with this demo.

Note: If you've created a Console project, remember to ensure that the Target Framework is set to .NET Framework 4. The default is .NET Framework 4 Client Profile, which doesn't work with LINQ to Twitter. You can check by double-clicking the Properties folder on the project and inspecting the Target Framework setting.

Next, you'll need to add some code to your program that you want to inspect. Here, I add code to instantiate a TwitterContext, which is like a LINQ to SQL DataContext, but works with Twitter:

var l2tCtx = new TwitterContext();

If you're following along add the code above to the Main method, which will look similar to this:

using LinqToTwitter;

namespace NuGetInstall
{
    class Program
    {
        static void Main(string[] args)
        {
            var l2tCtx = new TwitterContext();
        }
    }
}

The code above doesn't really do anything, but it does give something that I can show and demonstrate how JustCode decompilation works.

Once the code is in place, click on TwitterContext and press the F12 (Go to Definition) key. As expected, Visual Studio opens a metadata file with prototypes for the TwitterContext class. Here's the result:

Opening a metadata file is the normal way that Visual Studio works when navigating to the definition of a type where you don't have the code. The scenario with TwitterContext happens because you don't have the source code to the file. Visual Studio has always done this and you can experiment by selecting any .NET type, i.e. a string type, and observing that Visual Studio opens a metadata file for the .NET String type. The point I'm making here is that JustCode works the way Visual Studio works and you'll see how this can make your job easier.

In the previous figure, you only saw prototypes associated with the code. i.e. Notice that the default constructor is empty. Again, this is normal because Visual Studio doesn't have the ability to decompile code. However, that's the purpose of this post; showing you how JustCode fills that gap.

To decompile code, right click on TwitterContext in the metadata file and select JustCode Navigate -> Decompile from the context menu. The shortcut keys are Ctrl+1. After a brief pause, accompanied by a progress window, you'll see the metadata expand into full decompiled code. Notice below how the default constructor now has code as opposed to the empty member prototype in the original metadata:

And Why is This So Different?

Again, the big deal is that Telerik JustCode decompilation works in harmony with the way that Visual Studio works. The navigate to functionality already exists and you can use that, along with a simple context menu option (or shortcut key) to transform prototypes into decompiled code.

Telerik is filling the the Reflector/Red Gate gap by providing a supported alternative to decompiling code. Many people, including myself, used Reflector to decompile code when we were stuck with buggy libraries or insufficient documentation. Now we have an alternative that's officially supported by a company with an excellent track record for customer (developer) service, Telerik. Not only that, JustCode has several other IDE productivity tools that make the deal even sweeter.

Joe

Released LINQ to Twitter Beta v2.0.20

Joe Mayo — Mon, 07 Mar 2011 03:24:29 GMT

I released LINQ to Twitter Beta v2.0.20: http://goo.gl/1i97X. Most of the items were bug fixes. A couple items were new: Geo Search and I finished adding Asynch support for non-Silverlight APIs.

Joe

Debugging Windows Service Timeout Error 1053

Joe Mayo — Thu, 03 Mar 2011 19:20:37 GMT

If you ever receive an Error 1053 for a timeout when starting a Windows Service you've written, the underlying problem might not have anything to do with a timeout. Here's the error so you can compare it to what you're seeing:

---------------------------
Services
---------------------------
Windows could not start the Service1 service on Local Computer.

Error 1053: The service did not respond to the start or control request in a timely fashion.

---------------------------
OK
---------------------------

Searching the Web for a solution to this error in your Windows Service will result in a lot of wasted time and advice that won't help. Sometimes you might get lucky if your problem is exactly the same as someone else's, but this isn't always the case. One of the solutions you'll see has to do with a known error on Windows Server 2003 that's fixed by a patch to the .NET Framework 1.1, which won't work. As I write this blog post, I'm using the .NET Framework 4.0, which is a tad bit past that timeframe.

Most likely, the basic problem is that your service is throwing an exception that you aren't handling. To debug this, wrap your service initialization code in a try/catch block and log the exception, as shown below:

using System;
using System.Diagnostics;
using System.ServiceProcess;

namespace WindowsService
{
    static class Program
    {
        static void Main()
        {
            try
            {
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[] 
			    { 
				    new Service1() 
			    };
                ServiceBase.Run(ServicesToRun);
            }
            catch (Exception ex)
            {
                EventLog.WriteEntry("Application", ex.ToString(), EventLogEntryType.Error);
            }
        }
    }
}

After you uninstall the old service, redeploy the service with modifications, and receive the same error message as above; look in the Event Viewer/Application logs. You'll see what the real problem is, which is the underlying reason for the timeout.

Joe

LINQ to Twitter Queries with LINQPad

Joe Mayo — Thu, 24 Feb 2011 18:31:55 GMT

LINQPad is a popular utility for .NET developers who use LINQ a lot. In addition to standard SQL queries, LINQPad also supports other types of LINQ providers, including LINQ to Twitter. The following sections explain how to set up LINQPad for making queries with LINQ to Twitter.

LINQPad comes in a couple versions and this example uses LINQPad4, which runs on the .NET Framework 4.0.

1. The first thing you'll need to do is set up a reference to the LinqToTwitter.dll. From the Query menu, select query properties. Click the Browse button and find the LinqToTwitter.dll binary. You should see something similar to the Query Properties window below.

2. While you have the query properties window open, add the namespace for the LINQ to Twitter types. Click the Additional Namespace Imports tab and type in LinqToTwitter. The results are shown below:

3. The default query type, when you first start LINQPad, is C# Expression, but you'll need to change this to support multiple statements. Change the Language dropdown, on the Main window, to C# Statements.

4. To query LINQ to Twitter, instantiate a TwitterContext, by typing the following into the LINQPad Query window:

var ctx = new TwitterContext();

Note: If you're getting syntax errors, go back and make sure you did steps #2 and #3 properly.

5. Next, add a query, but don't materialize it, like this:

var tweets =
	from tweet in ctx.Status
	where tweet.Type == StatusType.Public
	select new
	{
		tweet.Text,
		tweet.Geo,
		tweet.User
	};

6. Next, you want the output to be displayed in the LINQPad grid, so do a Dump, like this:

tweets.Dump();

The following image shows the final results:

That was an unauthenticated query, but you can also perform authenticated queries with LINQ to Twitter's support of OAuth. Here's an example that uses the PinAuthorizer (type this into the LINQPad Query window):

var auth = new PinAuthorizer
{
	Credentials = new InMemoryCredentials
	{
		ConsumerKey = "",
		ConsumerSecret = ""
	},
	UseCompression = true,
	GoToTwitterAuthorization = pageLink => Process.Start(pageLink),
	GetPin = () =>
	{
		// this executes after user authorizes, which begins with the call to auth.Authorize() below.
		Console.WriteLine("\nAfter you authorize this application, Twitter will give you a 7-digit PIN Number.\n");
		Console.Write("Enter the PIN number here: ");
		return Console.ReadLine();
	}
};

// start the authorization process (launches Twitter authorization page).
auth.Authorize();

var ctx = new TwitterContext(auth, "https://api.twitter.com/1/", "https://search.twitter.com/");

var tweets =
	from tweet in ctx.Status
	where tweet.Type == StatusType.Public
	select new
	{
		tweet.Text,
		tweet.Geo,
		tweet.User
	};

tweets.Dump();

This code is very similar to what you'll find in the LINQ to Twitter downloadable source code solution, in the LinqToTwitterDemo project. For obvious reasons, I changed the value assigned to ConsumerKey and ConsumerSecret, which you'll have to obtain by visiting http://dev.twitter.com and registering your application.

One tip, you'll probably want to make this easier on yourself by creating your own DLL that encapsulates all of the OAuth logic and then call a method or property on you custom class that returns a fully functioning TwitterContext. This will help avoid adding all this code every time you want to make a query.

Now, you know how to set up LINQPad for LINQ to Twitter, perform unauthenticated queries, and perform queries with OAuth.

Joe

A Basic Thread

Joe Mayo — Tue, 22 Feb 2011 05:30:07 GMT

Most of the programs written are single-threaded, meaning that they run on the main execution thread. For various reasons such as performance, scalability, and/or responsiveness additional threads can be useful. .NET has extensive threading support, from the basic threads introduced in v1.0 to the Task Parallel Library (TPL) introduced in v4.0. To get started with threads, it's helpful to begin with the basics; starting a Thread.

Why Do I Care?

The scenario I'll use for needing to use a thread is writing to a file. Sometimes, writing to a file takes a while and you don't want your user interface to lock up until the file write is done. In other words, you want the application to be responsive to the user.

How Would I Go About It?

The solution is to launch a new thread that performs the file write, allowing the main thread to return to the user right away. Whenever the file writing thread completes, it will let the user know. In the meantime, the user is free to interact with the program for other tasks. The following examples demonstrate how to do this.

Show Me the Code?

The code we'll use to work with threads is in the System.Threading namespace, so you'll need the following using directive at the top of the file:

using System.Threading;

When you run code on a thread, the code is specified via a method. Here's the code that will execute on the thread:

        private static void WriteFile()
        {
            Thread.Sleep(1000);
            Console.WriteLine("File Written.");
        }

The call to Thread.Sleep(1000) delays thread execution. The parameter is specified in milliseconds, and 1000 means that this will cause the program to sleep for approximately 1 second. This method happens to be static, but that's just part of this example, which you'll see is launched from the static Main method. A thread could be instance or static.

Notice that the method does not have parameters and does not have a return type. As you know, the way to refer to a method is via a delegate. There is a delegate named ThreadStart in System.Threading that refers to a method without parameters or return type, shown below:

            ThreadStart fileWriterHandlerDelegate =
                new ThreadStart(WriteFile);

I'll show you the whole program below, but the ThreadStart instance above goes in the Main method. The thread uses the ThreadStart instance, fileWriterHandlerDelegate, to specify the method to execute on the thread:

            Thread fileWriter = new Thread(fileWriterHandlerDelegate);

As shown above, the argument type for the Thread constructor is the ThreadStart delegate type. The fileWriterHandlerDelegate argument is an instance of the ThreadStart delegate type. This creates an instance of a thread and what code will execute, but the new thread instance, fileWriter, isn't running yet. You have to explicitly start it, like this:

            fileWriter.Start();

Now, the code in the WriteFile method is executing on a separate thread. Meanwhile, the main thread that started the fileWriter thread continues on it's own. You have two threads running at the same time.

Okay, I'm Starting to Get Glassy Eyed. How Does it All Fit Together?

The example below is the whole program, pulling all the previous bits together. It's followed by its output and an explanation.

using System;
using System.Threading;

namespace BasicThread
{
    class Program
    {
        static void Main()
        {
            ThreadStart fileWriterHandlerDelegate =
                new ThreadStart(WriteFile);

            Thread fileWriter = new Thread(fileWriterHandlerDelegate);

            Console.WriteLine("Starting FileWriter");

            fileWriter.Start();

            Console.WriteLine("Called FileWriter");
            Console.ReadKey();
        }

        private static void WriteFile()
        {
            Thread.Sleep(1000);
            Console.WriteLine("File Written");
        }
    }
}

And here's the output:

Starting FileWriter
Called FileWriter
File Written

So, Why are the Printouts Backwards?

The output above corresponds to Console.Writeline statements in the program, with the second and third seemingly reversed. In a single-threaded program, "File Written" would print before "Called FileWriter". However, this is a multi-threaded (2 or more threads) program. In multi-threading, you can't make any assumptions about when a given thread will run. In this case, I added the Sleep statement to the WriteFile method to greatly increase the chances that the message from the main thread will print first. Without the Thread.Sleep, you could run this on a system with multiple cores and/or multiple processors and potentially get different results each time.

Interesting Tangent but What Should I Get Out of All This?

Going back to the main point, launching the WriteFile method on a separate thread made the program more responsive. The file writing logic ran for a while, but the main thread returned to the user, as demonstrated by the print out of "Called FileWriter". When the file write finished, it let the user know via another print statement. This was a very efficient use of CPU resources that made for a more pleasant user experience.

Joe

An MVC 3 Contact Form

Joe Mayo — Sun, 31 Oct 2010 00:27:57 GMT

Many sites have a contact form, instead of posting email addresses. Admittedly, email addresses are convenient for customers because they can use a mailto link that brings up their email client and allow them to start typing, archive the communication, and manage the thread. When I first started C# Station, that’s what I did; posted my email address for everyone. Holy cow, what a mistake. I received so much spam that my inbox was unusable. Fortunately, spam is more manageable these days, but it’s still a problem. Therefore, C# Station takes a balanced approach by allowing people to contact me, yet protect my email address. The following shows how I built the new contact form with ASP.NET MVC 3.

The Controller

Previously, I blogged about the organization of my site and how the About page was the last menu item. What I’m doing now is hanging the Contact menu item off About, along with other miscellaneous subjects like Terms, Contribute, and LinkToMe. Therefore, I created an About controller to group these items together:

using System.Web.Mvc;
using CssMvc.Library;
using CssMvc.Models;

namespace CssMvc.Controllers
{
    public class AboutController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }

        public ActionResult Contact()
        {
            return View(new ContactViewModel());
        }

        [HttpPost]
        public ActionResult Contact(ContactViewModel contactVM)
        {
            if (!ModelState.IsValid)
            {
                return View(contactVM);
            }

            var contact = new Contact
            {
                From = contactVM.From,
                Subject = contactVM.Subject,
                Message = contactVM.Message
            };

            new Email().Send(contact);

            return RedirectToAction("ContactConfirm");
        }

        public ActionResult ContactConfirm()
        {
            return View();
        }

        public ActionResult LinkToMe()
        {
            return View();
        }

        public ActionResult Contribute()
        {
            return View();
        }

        public ActionResult Terms()
        {
            return View();
        }
    }
}

As you can see, there is a parameterless Contact action whose purpose is to display a Contact view. There’s also a Contact action, with a ContactViewModel parameter that I’ll return to later. Right now, take a look at the parameterless Contact, which shows a blank contact form, it passes a new instance of ContactViewModel, which is empty, to the View. If you’ve been working with ASP.NET MVC, this is nothing different than what you’ve seen before. Let’s take an closer look at ContactViewModel.

The Model

“Model” is one of those overloaded and overused buzzwords that software engineers love to sprinkle into conversation. Okay, I love to say “Model” because it makes me sound like I know what I’m talking about. Anyway, I like to suffix my model names with ViewModel, which is what plenty of other people do too. Since I wanted a form with contact data, I called my object ContactViewModel and coded it like this:

using System.ComponentModel.DataAnnotations;

namespace CssMvc.Models
{
    public class ContactViewModel
    {
        [Required]
        [DataType(DataType.EmailAddress)]
        public string From { get; set; }

        [Required]
        public string Subject { get; set; }

        [Required]
        public string Message { get; set; }
    }
}

ContactViewModel doesn’t show anything new. The annotations feature was introduced in MVC 2. It’s a simple ViewModel, but it does reflect what I want to show on my screen. As you know, email messages have many more fields than shown here. The trick is to only use what you need in the ViewModel and let’s its purpose be presentation driven. Speaking of presentation, let’s see what the form looks like.

The View

So far, if already accustomed to MVC 2, you haven’t seen anything new. However, now I’ll show you the View, which uses the new MVC 3 Razor view engine. This view displays a Contact form that lets the user enter a From address, Subject, and Message; the same data items you saw in the ContactViewModel:

@model CssMvc.Models.ContactViewModel

@{
View.Title = "Contact Joe Mayo";
Layout = "~/Views/Shared/_Layout.cshtml";
}

@using (Html.BeginForm()) {
    @Html.ValidationSummary(true)
    <fieldset>
        <legend>Contact Joe Mayo</legend>
        <div class="editor-label">
            @Html.LabelFor(model => model.From)
        </div>
        <div class="editor-field">
            @Html.TextBoxFor(model => model.From)
            @Html.ValidationMessageFor(model => model.From)
        </div>
        <div class="editor-label">
            @Html.LabelFor(model => model.Subject)
        </div>
        <div class="editor-field">
            @Html.TextBoxFor(model => model.Subject)
            @Html.ValidationMessageFor(model => model.Subject)
        </div>
        <div class="editor-label">
            @Html.LabelFor(model => model.Message)
        </div>
        <div class="editor-field">
            @Html.TextBoxFor(model => model.Message)
            @Html.ValidationMessageFor(model => model.Message)
        </div>
        <p>
            <input type="submit" value="Send" />
        </p>
    </fieldset>
}

Besides my personal branding, the first thing you might notice is that the Razor view engine is much cleaner than the ASPX view engine. Binding directives, “<%= … %>”, are replaced by "@…”. The helpers and logic are the same. MVC 3 has more helpers, but I’m not covering those in this post.

Notice the @model directive at the top of the View. This is the new way to specify that this is a strongly typed view. It’s new for the latest release of MVC 3 also because the strongly typed view syntax was more verbose in the previous MVC3 release. @ScottGu does a good job of covering Razor in his blog and in subsequent posts.

A code block, denoted by “@{ … }”, follows the @model directive, where you can write multiple lines of code. View.Title demonstrates a new feature in Razor, using the new dynamic type feature added to C# 4.0. There is no Title property on View. Behind the scenes, the syntax is really View[“Title”], which you would have used in MVC 2; more discussion later to round out the picture and show how this is used. Layout is analogous to an ASPX Master page and I’ll discuss that in a moment.

A very nice feature of Razor is that you don’t need to block off normal code with <% and %>. As demonstrated by the using statement, all you need to do is use the @ prefix, as in @using, and Razor will recognize the difference between code and HTML. This was a normal *.cshtml View page; layout pages, which I breezed over, use similar syntax.

The Layout Page

Instead of Master pages, Razor has Layout pages. Many of the concepts between Master and Layout are the same, except for the syntax. In your VS 2010 project structure, Layout pages reside in Views\Shared, just like Master pages. Here’s the (work in progress) Layout page for C# Station:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>@View.Title</title>
<link href="@Url.Content("~/Content/Site.css")" rel="stylesheet" type="text/css" />
</head>

        <div id="header">
            <div id="title">
                <h1>C# Station</h1>
            </div>

            <div id="logindisplay">
                @Html.Partial("_LogOnPartial")
            </div>

                <ul id="menu">
                    <li>@Html.ActionLink("Home", "Index", "Home")</li>
                    <li>@Html.ActionLink("About", "Index", "About")</li>
                    <li>@Html.ActionLink("Contact", "Contact", "About")</li>
                </ul>

</div>
</div>

        <div id="main">
            @RenderBody()
            <div id="footer">
            </div>
        </div>
    </div>
</body>
</html>

If you recall from the last section, I discussed how the Title in View.Title was using the dynamic typing features in C#. In the <head> you can see how <title> is set, using this dynamic type. This is easier to type, read, and eliminates needing to explicitly use string indexes.

Again, you can see how the @Url and @Html syntax helps reduce typing and results in cleaner code.

The linkage between View and Layout occurs at @RenderBody(). The View specifies what the Layout is and the Layout page specifies where where the contents of the view are rendered. There are more Layout features that allow you to define where parts of the View render for more sophisticated scenarios, but what you’re seeing here covers many situations, is minimal syntax, and very simple.

Next, we’ll take a step back to the controller so we can round out the discussion with the business logic that makes this Contact form work.

The Business Logic

Clicking the input button, from the code in the previous section on The View, posts the form contents to the Contacts action in the About controller, repeated here for your convenience:

        [HttpPost]
        public ActionResult Contact(ContactViewModel contactVM)
        {
            if (!ModelState.IsValid)
            {
                return View(contactVM);
            }

            var contact = new Contact
            {
                From = contactVM.From,
                Subject = contactVM.Subject,
                Message = contactVM.Message
            };

            new Email().Send(contact);

            return RedirectToAction("ContactConfirm");
        }

I can validate the model because of the annotations in ContactViewModel. If the model is valid, I populate the business object, of type Contact, which is passed to the Send method of an instance of another custom business object named Email. Here’s Contact:

namespace CssMvc.Library
{
    public class Contact
    {
        public string From { get; set; }

        public string Subject { get; set; }

        public string Message { get; set; }
    }
}

You can see that Contact looks nearly identical to ContactViewModel. A common question is “Why duplicate the same object in two places?”. Really, this isn’t duplication. ContactViewModel has annotations that are only meaningful in the presentation layer. You don’t want annotations in your business objects because it makes them only usable in a context that understands the annotations. Before you ding me for splitting hairs, there’s more to the value of separating the ViewModel from the business model.

You can’t see it in this example, because both objects contain the same fields, but in most scenarios the ViewModel differs in content and structure from the business model. The business logic will often return a set of data in a shape that is either flat or separated from different calls into business logic. However, the ViewModel should shape the data for how it will appear on the screen. If you let me wave my hands for a moment -- you could have some basic information, such as a Product defined by fields in a ProductViewModel, and then have details of that product in a List<ProductDetailViewModel>. Coming from your repository, this data might be separate and you would need to combine it into a single ViewModel object, in a form that mirrors the HTML layout in the View.

Another aspect to be aware of is that the business model will often contain more data than the view requires. Model binding is an automatic process (can be custom, but that’s orthogonal to the point I’m trying to make) and you don’t want to waste CPU cycles on trying to bind business object fields that aren’t being used.

You might then wonder, “What if you wrote the business logic to return the data in the right shape?”. However, that’s just plain bass-ackwards to proper architecture and design because the business logic shouldn’t have any knowledge of the presentation layer. Besides, like annotations, that would tie your business logic to a particular implementation, precluding reuse. To continue the focus on separate business logic, here’s the Email implementation:

using System.Configuration;
using System.Net.Mail;

namespace CssMvc.Library
{
    public class Email
    {
        public void Send(Contact contact)
        {
            MailMessage mail = new MailMessage(
                contact.From,
                ConfigurationManager.AppSettings[Keys.ContactToEmail],
                contact.Subject,
                contact.Message);

            new SmtpClient().Send(mail);
        }
    }
}

My mail server configuration is in Web.config system.net\mailSettings and Keys is a class I use to add a set of const string fields to avoid string typos in my code. Frequently, I’ll encounter a need to send email in different configurations, so it’s just easy to create an Email class and group the different email methods in one place.

Notice the CssMvc.Library namespace (Css means C# Station, in case you were subliminally confused with some other meaning), which implies a separation between the MVC code and the business logic. In fact, the separation is explicit because I put the business logic in a separate class library. This is handy for a number of reasons, but I’ll leave that for another discussion; I personally like the explicit separation between presentation and business logic.

Summary

You’ve seen how I created a simple Contact form, combining current MVC 2 coding techniques with new MVC 3 features. The most noticeable change in MVC 3 is the Razor view engine. As you see, the coding experience is quicker and cleaner. I’d also like to give honorable mention to the clever use of dynamic typing, as demonstrated with the View.Title property, which makes View model dictionary access easier to create and read. I finally got around to discussing my views on separation of presentation and business logic by describing why I think the ViewModel should be separate from the business model and how I place business logic into a separate library. Most of the code shown here is on the Happy Path, except for field validation, but it simplified the example and hopefully let me share something you might find useful.

Joe

Named Arguments Can Improve Readability

Joe Mayo — Mon, 11 Oct 2010 17:04:27 GMT

Using named arguments everywhere is tedious and unnecessary, but can be applied as needed to improve the readability of your code. Here’s an example, using Directory.Delete() that helps document the meaning of a bool argument:

Directory.Delete(pathToDelete, recursive: true);

If Directory.Delete was your own code, you could re-write the parameter to use an Enum and get away from the bool code smell. However, Directory is a class in the .NET Framework’s System.Diagnostics namespace, which demonstrates a situation that you can’t change yourself. There might be other ways to make this code self documenting, but now that we have named arguments, it’s pretty easy to add the name whenever you think it might help.

Joe