David Hayden

Leveraging ASP.NET MVC - Web Forms - DynamicData - Castle ActiveRecord

We had a wonderful turnout for the first Sarasota Web Developer Group Meeting. The room was packed and the dialog was fantastic. You can read the Sarasota Web Developer Group First Meeting Recap.

The second meeting of the Sarasota Web Developer Group will be on Wednesday, March 24, 2010 at 6pm at the Community Foundation of Sarasota. 

David Hayden will be presenting 3 topics:

• Presentation 1: Build ASP.NET MVC Contact Manager from Scratch
• Tool Spotlight: Castle ActiveRecord, SQLite, and NHProf
• Presentation 2: Get RAD with DynamicData

Please register to attend so that we have an accurate count for pizza. Only those registering are eligible for prizes.

Building ASP.NET MVC Contact Manager from Scratch

David will start with a new ASP.NET MVC Web Application Project and show you how to create controllers, views, and a domain model from scratch to manage a list of contacts. The presentation will leverage the power of T4 Templates, strongly-typed views, the DefaultModelBinder, System.ComponentModel.DataAnnotations for validation, Microsoft ASP.NET AJAX for client-side validation, and Castle ActiveRecord for data access.

Tool Spotlight: Castle ActiveRecord, SQLite, and NHProf

David will dive into the wonders of Castle ActiveRecord for database access using Model First Development. With a few simple configuration settings in Web.config and attributes on a domain entity we will have Castle ActiveRecord create the necessary schema in a SQLite Database and provide database access using the wonders of LINQ. NHProf will profile ActiveRecord's communication with the database, providing us peace of mind as well as warning us of common pitfalls.

Get RAD with DynamicData

David shows you how to leverage the power of DynamicData to rapidly build a data-driven website as well as add DynamicData functionality to an existing ASP.NET Web Forms Website. Use the built-in scaffolding and default templates to get started quickly and modify the behavior as needed by creating custom templates or modifying the database model's schema.

Homework Assignment

David will announce the first homework assignment that will challenge your knowledge of ASP.NET MVC. The homework will be based on the Contact Manager ASP.NET MVC Application discussed during the first two meetings and should take no more than 15 - 30 minutes to complete. Members who complete the assignment will be eligible to win more prizes!

Looking forward to seeing you all at the second meeting! Register now if you plan to attend. Pizza and beverages will be provided!

David Hayden

Sarasota Web Development Group - First Meeting Recap

We had a huge turnout at the first meeting of the Sarasota Web Development Group. The room was packed and the participation was fantastic! Lots of great dialog on the three presentations I gave to the group:

• Introduction to ASP.NET MVC
• Tool Spotlight: Microsoft IIS SEO Toolkit
• Overview of ASP.NET 4 and ASP.NET 4 Webforms Enhancements

A huge thank you to CodeBetter.com for sponsoring the pizza and beverages for the evening as well as a huge thank you to Developer Express, TekPub, Manning, and Wrox for the wonderful giveaways that evening!

Introduction to ASP.NET MVC

I gave an overview of the ASP.NET MVC Framework. Created an ASP.NET MVC Web Application from scratch and discussed the differences in ASP.NET MVC with regards to ASP.NET Web Forms and emphasized:

• The Model-View-Controller Architecture
• RESTful Routing
• Strongly-Typed Views
• Controllers and Actions
• View Helpers
• ActiveRecord via Castle ActiveRecord
• HttpGet and HttpPost Attributes

Next month we will dive into a CRUD Contact Manager Application. I will build the controllers, views, and domain model from scratch. Castle ActiveRecord and SQLite will be used for the data access layer and database of choice. The first homework assignment will be to fill out the missing areas of the ContactsController.

Microsoft IIS SEO Toolkit

Each meeting I pick a particular .NET Developer Tool to demonstrate to the Sarasota Web Developer Group. This month's tool was the Microsoft IIS SEO Toolkit to help with the search engine optimization of your websites. I discussed the Site Analysis portion and reviewed how to analyze a website for errors, performance issues, and  warnings. I showed how the SiteMap and Robot.txt modules can help one create sitemap.xml and robot.txt files for local IIS websites.

Overview of ASP.NET 4 and ASP.NET 4 Webforms Enhancements

In addition to ASP.NET MVC and the Microsoft IIS SEO Toolkit, I presented a number of the ASP.NET 4 and ASP.NET 4 Webforms Enhancements that we will with Visual Studio 2010:

• The simplified Web.config
• The new Response.RedirectPermanent and new routing engine derivatives
• Page.MetaKeywords and Page.MetaDescription for SEO
• The new Routing Engine along with Page.RouteData, RouteParameter, and Expression Builders that go with it
• The ClientIDMode and the effects of Static, Predictable, AutoID, and Inherit
• Html Encoded Code Expressions
• Chart Control
• CSS Improvements with examples of Menu Control and RemoveOuterTable
• ViewStateMode for a bit more control over ViewState

Conclusion

If you are interested in learning the new enhancements in ASP.NET 4 and ASP.NET 4 Web Forms as well as ASP.NET MVC from Scratch and live anywhere near Sarasota, Florida, I highly encourage you to join the Sarasota Web Developer Group. Meeting build upon the skills and confidence of members each month and teach them real-world, marketable skills in ASP.NET 4, ASP.NET 4 Web Forms, and ASP.NET MVC.

You can register for upcoming meetings here.

David Hayden

Sarasota Web Developer Group Leader

ASP.NET 4 Search Engine Optimization ( SEO ) Features

ASP.NET 4 has a few features that help with Search Engine Optimization ( SEO ) and dealing with search engines in general. The two features I am thinking about are:

• Page.MetaKeywords and Page.MetaDescription
• Response.RedirectPermanent

Although these seo features are not revolutionary they certainly do help make things easier. The ability of Page.MetaKeywords and Page.MetaDescription to help populate your websites with keywords and description used by search engines is a convenient feature. The ability to use Response.RedirectPermanent to help inform search engines of permanent changes in your website’s structure is also a very helpful features.

As an FYI, I will be talking about these new ASP.NET 4 features and more at the Sarasota Web Developer Group as well as showing off the new IIS SEO Toolkit.

Page.MetaKeywords and Page.MetaDescription

Although the meta keywords and meta description tags are not as valuable as they once were with respect to search engine optimization, you certainly don’t want to ignore them. In ASP.NET 4 the Page Class now has a couple of properties that allow you to set them with ease. If we look at the code-behind of an ASP.NET 4 Page, we can see the simple use of populating the keywords and description tags for SEO purposes:

protected void Page_Init(object sender, EventArgs e)
{
  Page.Title = "ASP.NET 4 SEO Features";
  Page.MetaKeywords = "seo,search engine optimization,asp.net";
  Page.MetaDescription = "Search engine optimization features in ASP.NET 4";
}

The nice thing about the new Page.MetaKeywords and Page.MetaDescription Properties is that they describe your intentions well. Although I am using static values here for sake of simplicity, the goal would be to populate these properties from data in some sort of datastore, like a database, xml file, etc.

Response.RedirectPermanent in ASP.NET 4

For various reasons the structure of you website may change and content located at one URL may be re-located permanently to another URL. In these cases, you want to inform search engines of this change by responding to their request at the old URL with an HTTP Status Code of 301 – Moved Permanently. This tells the search engine to update its links in the database with the new URL information provided. The new way to send an HTTP 301 Moved Permanently status is using Response.RedirectPermanent in ASP.NET 4:

protected void Page_Init(object sender, EventArgs e)
{
  Response.RedirectPermanent("newlocation");
}

If you were using Response.Redirect in the past for redirecting users to permanent URL changes, you were sending an HTTP Status Code 302 Found, which is only for temporary redirection of content. This is okay for temporary redirects, but for permanent changes in URL’s you really should use Response.RedirectPermanent in ASP.NET 4 to help search engines index your websites appropriately.

Conclusion

We will be talking more about the new features in ASP.NET 4 during the upcoming weeks. If you are Florida Web Developer and interested in learning ASP.NET 4 and ASP.NET MVC 2 from scratch, be sure to attend the Sarasota Web Developer Group if you are located in the area. You can read more about the first meeting of the Sarasota Web Development Group.

Hope this helps.

David Hayden

Enterprise Library 5 ConfigurationSourceBuilder and Fluent Interfaces - DAAB Example

I am not a huge fan of XML for configuration, but I also don’t want to go crazy with fluent interfaces when a bit of XML will do the trick. Hard to say when I prefer one over the other at times so it is always nice to have the option of XML or a fluent interface.

One of the nice features in Enterprise Library 5 is the option of a fluent interface to configure your application blocks. I have briefly played with the fluent interface to configure the Data Access Application Block, which is probably one of the simplest to configure. I am not qualified to judge the implementation of the fluent interface at this point so I will mainly just point out some quick findings and show some code.

ConfigurationSourceBuilder

ConfigurationSourceBuilder seems to be the main class involved with building configuration information using a fluent interface. It looks to me that each block adds an extension method to this class to fluently configure that application block. In the case of the Data Access Application Block, it adds an extension method, called ConfigureData(), to ConfigurationSourceBuilder that allows you to fluently configure the DAAB. Once you are done configuring all blocks, you essentially build the configuration source and then use it to populate your container.

That is clear as mud without an example, so here is a quick bit of code using ConfigurationSourceBuilder, ConfigureData(), DictionaryConfigurationSource, and EnterpriseLibraryContainer to set-up the IoC Container and use it to get at the default database as well as a named instance:

var builder = new ConfigurationSourceBuilder();

// Extension Method
builder.ConfigureData()
      .ForDatabaseNamed("Test")
        .ThatIs.ASqlDatabase()
        .WithConnectionString("...")
        .AsDefault()
      .ForDatabaseNamed("Test2")
        .ThatIs.ASqlDatabase()
        .WithConnectionString("...");

// Create ConfigurationSource
var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);

// Set Container
EnterpriseLibraryContainer.Current
  = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);

// Get Default Database
var database = EnterpriseLibraryContainer.Current
         .GetInstance<Database>();

// Get Named Instance of Database
var database2 = EnterpriseLibraryContainer.Current
         .GetInstance<Database>("Test2");

Pretty straightforward really. If the EnterpriseLibraryContainer throws you a bit, read a little about IServiceLocator at EnterpriseLibraryContainer and IServiceLocator in Enterprise Library 5. This is just Microsoft Patterns & Practices attempt to let you use the IoC Container of your choice ( Autofac, Ninject, Windsor, StructureMap, etc. ) from within Enterprise Library.

Conclusion

I want to play with the fluent interface in Enterprise Library 5 a lot more, but indeed, I already love the simplicity of it compared to what we had to do in the past to configure various application blocks in code. Between this and the new GUI Configuration Editor in EntLib 5, things have certainly changed a bit with regards to configuration.

For those developers who have yet to consider fluent interfaces or don’t see the value, the XML configuration is still there and I doubt that it will be going anywhere anytime soon.

Hope this helps.

David Hayden

LINQ and Deferred Execution using Iterators and Enumerable.Range

One of the obvious benefits of LINQ is the focus on a more declarative style of development where the code focuses more on the developer’s intent as opposed to how the end result is achieved.

Another benefit is the whole deferred execution aspect and how information is provided in a just-in-time manner.

Take the simplest, but very clear, example where we want to find all odd integers. Using LINQ, one can start to process all the odd integers immediately using Enumerable.Range and LINQ as follows:

var ints = Enumerable.Range(1, Int32.MaxValue)
 .Where(i => i % 2 == 1)
 .Select(i => i);

foreach (var odd in ints)
 Console.WriteLine(odd);

This only starts processing immediately because Enumerable.Range doesn’t sit there and wait to collect all integers between 1 and Int32.MaxValue before returning values. It instead hands off an integer one at a time as it finds them. Enumerable.Range in spirit looks like this and uses an Iterator:

public static class Enumerable
{
 public static IEnumerable<int> Range(int start, int end)
 {
 for (int i = start; i <= end; i++)
 yield return i;
 }
}

Besides the obvious benefit of processing occurring just-in-time and results being returned right away, think of the memory savings. Our Range Method doesn’t need to set-up temporary storage to store integers from start to finish before handing the entire collection back to the caller.

This even gets more awesome when you think about wanting only a subset, odd numbers in this case, of all integers between 1 and Int32.MaxValue. You really don’t want the application to first go through all the trouble of finding all integers and then having to go back through that list and only pick out the odd ones.

We can make a Where Function that in spirit embodies the intent of LINQ:

public static class MyExtensions
{
 public static IEnumerable<T> Where<T>
 (this IEnumerable<T> sequence, Func<T, bool> filter)
 {
 foreach(var item in sequence)
 if (filter(item))
 yield return item;
 }
}

This is very slick!

So maybe this still doesn’t hit one square in the noggin in terms of value. Well, let’s say we only wanted the first 200 odd integers. We obviously don’t want to waste our time getting integers past the first 200 odd integers and luckily we don’t have to:

var ints = Enumerable.Range(1, Int32.MaxValue)
 .Where(i => i % 2 == 1)
 .Select(i => i);

int count = 0;

foreach (var odd in ints)
{
 Console.WriteLine(odd);
 count++;
 if (count == 200) break;
}

Console.ReadLine();

Update: Great point by Andrey below about using LINQ .Take for getting just the top 200 items. Although I thought about using it, I don't think it really hits home the idea of delayed execution and Iterators. Nonetheless, you should of course use .Skip, .Take, etc when trying to get a page of items from a sequence as such:

var ints = Enumerable.Range(1, Int32.MaxValue)
 .Where(i => i % 2 == 1)
 .Select(i => i)
 .Take(200);

The loop I mention above would be sorta what you would find in the Take Extension Method if we made our own:

public static class MyExtensions
{
 public static IEnumerable<T> Take<T>(this IEnumerable<T> sequence, int total)
 {
  int count = 0;

  foreach (var item in sequence)
  {
   count++;
   yield return item;
   if (count == total) break;
   }
 }
}

LINQ's deferred execution and use of iterators makes this oh so sweet.

Conclusion

Hopefully this clarifies some of the value of LINQ and Iterators for those still trying to get a grip on the subjects.

David Hayden

Default Values in ASP.NET MVC Action Parameters

You can’t help but notice the impact System.ComponentModel and System.ComponentModel.DataAnnotations have had on ASP.NET MVC 2. The DefaultModelBinder now supports all the validation attributes when doing model binding. The new template helpers in ASP.NET MVC 2, Html.DisplayFor, Html.EditorFor, Html.LabelFor, etc. use various attributes that affect the display of complex objects and their individual properties. And, as I will mention here quickly, you can also use the DefaultValue Attribute in System.ComponentModel to specify default values for action parameters.

[DefaultValue] Attribute in ASP.NET MVC 2

You may have optional parameters on your ASP.NET MVC 2 Actions that you want to set to a default value during model binding. A good example of this may be when paging a list of customers in your application where the pageSize is optional and defaults to 25. One can pull this off in many ways we won’t discuss here, but one of the simplest ways is to decorate the pageSize parameter in the action method with [DefaultValue(25)]. Below is an example:

public class CustomersController : Controller
{
 private readonly ICustomerDAO _dao;

 public CustomersController(ICustomerDAO dao)
 {
  _dao = dao;
 }

 public ActionResult Index(int itemIndex, [DefaultValue(25)]int pageSize)
 {
  var customers = _dao.Skip(itemIndex - 1).Take(pageSize);

  return View(customers);
 }
}

If pageSize is not provided during model binding, it will be set to the value of 25 as specified in the DefaultValue Attribute. If it is specified, say as a querystring parameter in the URL, pageSize will of course take on the value provided in the URL.

C# 4 Default Values

If you are developing your ASP.NET MVC 2 web application using C# 4, you can skip the use of the DefaultValue Attribute and just assign the default value to pageSize. Specifying default values in C# 4 works along with other new features in C# 4 concerning Named and Optional Parameters.

public class CustomersController : Controller
{
 private readonly ICustomerDAO _dao;

 public CustomersController(ICustomerDAO dao)
 {
  _dao = dao;
 }

 public ActionResult Index(int itemIndex, int pageSize = 25)
 {
  var customers = _dao.Skip(itemIndex - 1).Take(pageSize);

  return View(customers);
 }
}

Conclusion

I am really looking forward to ASP.NET MVC 2 being included with Visual Studio 2010 when it is released around April 12, 2010. When that happens I believe a number of developers will start to learn and appreciate the ASP.NET MVC Framework. Check out a list of ASP.NET MVC 2 Tutorials I wrote quite some time ago.

Hope this helps.

David Hayden

IResultSetMapper in Enterprise Library 5 DAAB

Hopefully you have read my other posts on Enterprise Library 5 DAAB for a bit of background as this post is going to be very quick and to the point:

• Database Accessors in Enterprise Library 5 DAAB - Database.ExecuteSprocAccessor
• EnterpriseLibraryContainer and IServiceLocator in Enterprise Library 5
• Database.ExecuteSqlStringAccessor and LINQ in Enterprise Library 5 DAAB
• IRowMapper via MapBuilder and Mapping Properties in EntLib 5 DAAB

IResultSetMapper

As mentioned before with regards to IRowMapper in Enterprise Library 5 DAAB, there are times when you need a bit more control over how to map the results being returned from the database to individual entities and/or the entire resultset.

When you need to control the binding to individual entities, IRowMapper is your savior. IRowMapper helps you map an individual IDataRecord to the entity to which it binds. When you need control at the ResultSet level, IResultSetMapper is your guy. IResultSetMapper works at the IDataReader level and allows you to control looping through the IDataReader as well as custom databinding of each IDataRecord if you so choose.

Using the same example from before with IRowMapper, below is an example of creating a custom IResultSetMapper, MyResultSetMapper, that loops through the entire resultset and returns IEnumerable<Contact>. Note that in this case I don’t really need control at the IDataReader level, but I did it for the sake of illustration.

class Program
{
 static void Main(string[] args)
 {
 var database = EnterpriseLibraryContainer.Current.GetInstance<Database>();
 var contacts = database.ExecuteSqlStringAccessor<Contact>
 ("SELECT Id, Email FROM Contacts", new MyResultSetMapper());

 foreach (var contact in contacts)
 Console.WriteLine(string.Format("{0}: {1}", contact.Id, contact.Email));

 Console.ReadLine();
 }
}

public class MyResultSetMapper : IResultSetMapper<Contact>
{
 public IEnumerable<Contact> MapSet(System.Data.IDataReader reader)
 {
 var contacts = new List<Contact>();

 while (reader.Read())
 contacts.Add(new Contact { Id = reader.GetInt32(0), Email = reader.GetString(1)});

 return contacts;
 }
}

public class Contact
{
 public int Id { get; set; }
 public string Name { get; set; }
 public string Email { get; set; }
}

There is a part of me that wants to use an iterator from within MyResultSetMapper as shown below, but I do not like to use yield return for deferred execution from within an open database connection, which is an expensive resource. Opinions may vary.

public class MyResultSetMapper : IResultSetMapper<Contact>
{
 public IEnumerable<Contact> MapSet(System.Data.IDataReader reader)
 {
 while (reader.Read())
 yield return new Contact { Id = reader.GetInt32(0), Email = reader.GetString(1)});
 }
}

The results of each entity are the same as when we used a custom IRowMapper in the last Enterprise Library 5 DAAB Tutorial:

Conclusion

Although I am sure I will write other Enterprise Library 5 DAAB Tutorials in the future, I think we hit most of the interesting changes. Time to move on to other changes in Enterprise Library 5.

Hope this helps.

David Hayden