In Part 1, I built a simple Northwind ASP.NET MVC application using Entity Spaces and maintained the Entity Spaces references throughout the application.  This is not a loosely coupled application, but it does allow for slick and easy Entity Spaces relationship mapping in the View and in other layers of the application.  The downside is that a reference to the Entity Spaces DLL's need to be made in each layer.

In Part Deux, I refactored the application to be loosely coupled.  This helps promote a very flexible and extendable application and maintain the separation of concerns.  In other words, the View or presentation layer, has no idea what kind of data layer is sending the data.

Ok, now what?  Well I stated I was going to try and implement a version of the application for SubSonic, and here it is! 

I'm doing this to make a point.  My goal was to test whether the "loose coupling" pattern holds true and it does, apart from a few changes I needed to make because of changing from Entity Spaces to SubSonic.  These changes are not critical or life changing, but I needed to do it because of the differences in the way SubSonic handles entity naming from Entity Spaces.

And the changes just reflect that you can find out whether your application can stand up to change, by trying to change something and see how much you need to do to handle that change.  In this case, I did need to make some minor changes, but not much.  And in the long run, I feel that the application is even more flexible than version two because of the changes I've made.  I'll explain...

What I mean is this:

In the Northwind database there are table names such as:

• Categories
• Territories
• Employees
• etc...

These are all plural.  There is nothing wrong with that, and Entity Spaces maintains the naming convention.  It will remove any "underscores" or "dots" that are contained in the table name and just squeeze the words together.  But SubSonic changes the plural names to singular names.

Let me add a disclaimer here, that I am not endorsing SubSonic or Entity Spaces.  But I personally prefer Entity Spaces because it seems to me to be more straight forward in the architecture, and it has saved me hours and hours of work building my application.  I have used SubSonic a little but I am not an expert so the code I will be showing you, may or may not be the most performance enhanced version.  You may know a better way of querying and that's fine.  I just wanted to show that by simply changing the data provider in the Repository, the higher layers need not be affected.

SO WHAT DOES THE TABLE NAME HAVE TO DO WITH ANYTHING?

The reason I brought this up, is that with Entity Spaces, since it keeps the naming convention of the table names intact, I created a separate set of model classes (in the singular) for each table I needed in the application.

So if there was a "Categories" table in the database, I created a "Category" class for the model that would be sent to the View.  This helps promote "loose coupling". 

The reason this had to be address for the SubSonic version is that there was a namespace collision between the generated SubSonic classes and the Model classes.

The SubSonic classes were given the namespace as such:

namespace ESNorthwind.MVC.Data

But the model classes already had that namespace. And when SubSonic makes all plural table names singular, that's where the collision occurred.

 You'll see in this image, the model classes are in the Model folder, and the SubSonic classes are in the Generated folder, and they have the same names.  If they are in the same namespace, they will collide.

So what I did, was refactor a bit so that it would work for either Entity Spaces or SubSonic, or for any other ORM classes that are generated for the application.  I moved the model classes into their own namespace, ESNorthind.MVC.Data.Model.

Of course this will break in many places all over the application, so I did a quick refactor, everywhere so that the model classes now point to the new namespace.

So anywhere that a model class existed in code like this:

Product product = service.GetProductById(id);

... it was changed to this...

ESNorthwind.MVC.Data.Model.Product product = service.GetProductById(id);

I included the full namespace to the class to prevent ambiguous naming.

The View code-behind went from this:

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using ESNorthwind.MVC.Data;

namespace ESNorthwind.MVC.Web.Views.Products
{
    public partial class Categories : ViewPage< IList<Category> >
    {
        public void Page_Load()
        {

        }
    }
}

... to this ...

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using ESNorthwind.MVC.Data;

namespace ESNorthwind.MVC.Web.Views.Products
{
    public partial class Categories : ViewPage< IList<ESNorthwind.MVC.Data.Model.Category> >
    {
        public void Page_Load()
        {

        }
    }
}

Notice the change in the ViewPage generic base class.

Now if I want to change back to Entity Spaces, I just need to modify the code in the Repository object and I'm done!

I kept the Entity Spaces code in the Repository object so you can see the similarity in their object model, but also the subtle differences.

/// <summary>
/// Get all suppliers.
/// </summary>
/// <returns></returns>
public IList<ESNorthwind.MVC.Data.Model.Supplier> GetSuppliers()
{
    /********************************************************************
     * * Begin Entity Spaces Code
     * *****************************************************************/

    //SuppliersCollection suppColl = new SuppliersCollection();
    //suppColl.LoadAll();

    //Supplier supplier = null;

    //List<Supplier> suppList = new List<Supplier>();
    //foreach (Suppliers supp in suppColl)
    //{
    //    supplier = new Supplier();
    //    supplier.SupplierID = (int)supp.SupplierID;
    //    supplier.CompanyName = supp.CompanyName;
    //    suppList.Add(supplier);
    //}
    //return suppList;

    /********************************************************************
     * * End Entity Spaces Code
     * *****************************************************************/

    /********************************************************************
     * * Begin SubSonic Code
     * *****************************************************************/

    SupplierCollection suppColl = new SupplierCollection();
    suppColl.Load();

    ESNorthwind.MVC.Data.Model.Supplier supplier = null;

    List<ESNorthwind.MVC.Data.Model.Supplier> suppList = new List<ESNorthwind.MVC.Data.Model.Supplier>();
    foreach (Supplier supp in suppColl)
    {
    supplier = new ESNorthwind.MVC.Data.Model.Supplier();
    supplier.SupplierID = (int)supp.SupplierID;
    supplier.CompanyName = supp.CompanyName;
    suppList.Add(supplier);
    }
    return suppList;

    /********************************************************************
     * * End SubSonic Code
     * *****************************************************************/
}

To those developers interested in ASP.NET MVC and SubSonic, I hope this helps. Rob Conery (the creator of SubSonic) has more information on ASP.NET MVC using SubSonic, so check out his Blog.

Thanks for watching!

You can download the file here, ESNorthwind.MVC_Pt3.zip (6.77 mb)

King Wilder.

In Part 1 of this short series, I discussed how to build a simple ASP.NET MVC application using Entity Spaces.  If you have any Object Oriented background you will have noticed that that application was what is called, "tightly coupled".  That means that one set of objects depends on another.  This is generally a bad idea as it makes your application less flexible and extendable.

In this article, I will discuss what changes are necessary to make the application "loosely coupled", which in turn will make it easier to extend.

"Coding to an interface, rather than to an implementation, makes your software easier to extend."

"By encapsulating what varies, you make your application more flexible, and easier to change."

"The best way to get good requirements is to understand what a system is supposed to do."

"Great software is easy to change and extend, and does what the customer wants it to do."

"Analysis helps you ensure your system works in a real-world context."

"A loosely coupled application means that your objects are independent of each other, in other words, changes to one object don't require you to make a bunch of changes to other objects."

I just got finished saying that I read the Head First book on Object Oriented Analysis and Design, and one of the mantra's in it was the last quote above.  And I violated it by creating the INorthwindRepository interface as such:

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public interface INorthwindRepository
    {
        CategoriesCollection GetCategories();
        ProductsCollection GetProducts();
        ProductsCollection GetProductsByCategoryName(string categoryName);
        Products GetProductById(int id);
        SuppliersCollection GetSuppliers();
        void SubmitChanges(Products product);
    }
}

The CategoriesCollection is an Entity Spaces specific collection!  So right off the bat I've limited the extendability of this application to... er... Entity Spaces.  Which isn't really a limitation to me, since Entity Spaces is all I would use, but for anyone else who would want to download this application and is not an Entity Spaces user, this would be very restricting and hard to adapt.

This instantly prevents the developer from easily plugging in their own data provider and having it work. 

So to make it easier for non-Entity Spaces users, this is what I need to do:

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public interface INorthwindRepository
    {
        IList<Category> GetCategories();
        IList<Product> GetProducts();
        IList<Product> GetProductsByCategoryName(string categoryName);
        Product GetProductById(int id);
        IList<Supplier> GetSuppliers();
        void SubmitChanges(Product product);
    }
}

"Code to an interface, not an implementation".

By using IList<Category>, it now allows the application to be provider agnostic.  It could care less who the data provider is.  This did, though, require a bit more coding to make it work as it should.

For those who don't know Entity Spaces, built-into the Entity Spaces framework is the option to build all classes and maintain hierarchical relationships between database tables.  In a normal application, not a loosely coupled application, this type of framework is the developers dream.

Let's say we are returning a Products entity and we need to get the CategoryName from the Categories entity.  Using Entity Spaces we could do something like this:

Products product = new Products();
product.LoadByPrimaryKey(4);

string categoryName = product.UpToCategoriesByCategoryID.CategoryName;

Entity Spaces can easily create those relationships for the developer.  But to have a loosely coupled application, where any layer above the Data layer is NOT dependent on the data provider, this is not a good thing.

So what do we do?

When generating the Entity Spaces classes, I can just not select the option to "Generate Hierarchical Model" so each entity is independent.  So now there would be no more, UpToCategoriesByCategoryID, property to the class.  This means of course, that we need to manually create or maintain that relationship in code.

This isn't necessarily a bad thing, it's just a slightly more time consuming task, but in the long run it makes the application more flexible.

HOW DOES THIS IMPACT THE ENTIRE APPLICATION?

It impacts it a little, but nothing drastic, especially for an application as small as this one.  I was able to refactor the entire application in an afternoon.  But this also means that you can remove the Entity Spaces references from the Services Project since there are no dependencies to Entity Spaces in this layer.

What I did have to add were classes that would directly act as the Model:

• Category
• Product
• Supplier

I built these classes manually to store the data from the repository that would then be passed to the Controller and then the View.  Notice that they are a singular, where the database tables are plural.

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public class Category
    {
        public int CategoryID { get; set; }
        public string CategoryName { get; set; }
        public string Description { get; set; }
        public string Picture { get; set; }
    }
}


using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public class Product
    {
        public int ProductID { get; set; }
        public string ProductName { get; set; }
        public int SupplierID { get; set; }
        public int CategoryID { get; set; }
        public string QuantityPerUnit { get; set; }
        public decimal UnitPrice { get; set; }
        public int UnitsInStock { get; set; }
        public Category Category { get; set; }
        public Supplier Supplier { get; set; }
    }
}


using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public class Supplier
    {
        public int SupplierID { get; set; }
        public string CompanyName { get; set; }
    }
}

What else had to change?  The NorthwindRepository class had to change a bit to store the data into the model classes instead of passing those Entity Spaces object up to the view.  So I had to do some relationship mapping. 

This is the GetProductById() in part one of the application:

/// <summary>
/// Get the product details by productid
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public Products GetProductById(int id)
{
    Products product = new Products();
    product.LoadByPrimaryKey(id);
    return product;
}

And here's the newly refactored method:

/// <summary>
/// Get the product details by productid
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public Product GetProductById(int id)
{
    // Get the Products data from the database using Entity Spaces.
    Products prod = new Products();
    prod.LoadByPrimaryKey(id);

    // Instantiate the model Product object to store the
    // data from the Entity Spaces objects.
    Product product = new Product();
    product.ProductID = (int)prod.ProductID;
    product.ProductName = prod.ProductName;
    product.SupplierID = (int)prod.SupplierID;
    product.CategoryID = (int)prod.CategoryID;
    product.QuantityPerUnit = prod.QuantityPerUnit;
    product.UnitPrice = (decimal)prod.UnitPrice;
    product.UnitsInStock = (int)prod.UnitsInStock;

    // Load the Entity Spaces object to get the CompanyName.
    Suppliers supp = new Suppliers();
    supp.LoadByPrimaryKey(product.SupplierID);

    // New up a model Supplier object to store the CompanyName.
    product.Supplier = new Supplier() { CompanyName = supp.CompanyName };

    // Load the Entity Spaces Categories object to get the CategoryName.
    Categories cat = new Categories();
    cat.LoadByPrimaryKey(product.CategoryID);

    // New up the model Category object to store the CategoryName.
    product.Category = new Category() { CategoryName = cat.CategoryName };

    // Return the model Product object.
    return product;
}

You'll see that there's a bit more code, but this has to be done in order to de-couple the model from the data provider. 

Here's the SubmitChanges method in the NorthwindRepository class:

Entity Spaces specific method:

public void SubmitChanges(Products product)
{
    product.Save();
}

And the loosely coupled method:

/// <summary>
/// Submit the changes to the database.
/// </summary>
/// <param name="product"></param>
public void SubmitChanges(Product product)
{
    // Load the Entity Spaces Products object based 
    // on the ProductID and get the new values
    // from the Product model passed in.
    Products prod = new Products();
    prod.LoadByPrimaryKey(product.ProductID);
    prod.ProductName = product.ProductName;
    prod.SupplierID = product.SupplierID;
    prod.CategoryID = product.CategoryID;
    prod.UnitPrice = product.UnitPrice;
    prod.Save();
}

Again, as I stated in the first article, I'm learning this as I go and as elated as I was to have the application work where I could pass along the Entity Spaces objects to the Views, when I thought about hooking up SubSonic as another test, I quickly realize that I couldn't with the application in it's present state.  Hence the need to refactor to make the application extendable and more flexible.


WHAT ABOUT THE SERVICES LAYER?

That's what's so nice about this pattern, the Service layer was the quickest fix of them all.  I just needed to change the return object types from the Entity Spaces specific objects or collections to model references, ex: IList<model>.

This is the GetProductsByCategoryName() method originally:

/// <summary>
/// Return the ProductsCollection based on the Category name.
/// </summary>
/// <param name="categoryName"></param>
/// <returns></returns>
public ProductsCollection GetProductsByCategoryName(string categoryName)
{
    ProductsCollection prodColl = _repository.GetProductsByCategoryName(categoryName);
    return prodColl;
}

And this is the new method:

/// <summary>
/// Return the ProductsCollection based on the Category name.
/// </summary>
/// <param name="categoryName"></param>
/// <returns></returns>
public IList<Product> GetProductsByCategoryName(string categoryName)
{
    IList<Product> prodColl = _repository.GetProductsByCategoryName(categoryName);
    return prodColl;
}

The only thing changed was the return types, ProductsCollection to IList<Product>.  Now other than maybe adding a few new methods in this class or applying any business logic, this class doesn't need to be modified if we change data providers.

SO WHAT HAPPENS TO THE WEB LAYER?

Let's see how this refactoring impacted the Web site layer.

First understand that the way Entity Spaces works, a reference to Entity Spaces needs to occur in the web site, since the Loader needs to be set in the Global.asax file.

using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace ESNorthwind.MVC
{
    public class GlobalApplication : System.Web.HttpApplication
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            //routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            //routes.MapRoute(
            //    "Default",                                              // Route name
            //    "{controller}/{action}/{id}",                           // URL with parameters
            //    new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
            //);

            routes.MapRoute("mvcroute", "{controller}/{action}/{id}"
                , new { controller = "products", action = "Index", id = "" }
                , new { controller = @"[^\.]*" });

        }

        protected void Application_Start()
        {
            RegisterRoutes(RouteTable.Routes);
            EntitySpaces.Interfaces.esProviderFactory.Factory = new EntitySpaces.LoaderMT.esDataProviderFactory();
        }
    }
}

So essentially, nothing has changed in this file.

WHAT ABOUT THE CONTROLLER CLASS?

The controller came out pretty much unscathed, only a couple things needed to be changed.  Edit and Update were the two methods that changed.

Here's the original methods:

public object Edit(int id)
{

    ProductsEditViewData viewData = new ProductsEditViewData();
    Products product = service.GetProductById(id);
    viewData.Product = product;

    if (TempData.ContainsKey("ErrorMessage"))
    {
    foreach (var item in TempData)
    {
        ViewData[item.Key] = item.Value;
    }
    }

    ViewData["CategoryID"] = new SelectList(service.GetCategories(), "CategoryID", "CategoryName", ViewData["CategoryID"] ?? product.CategoryID);
    ViewData["SupplierID"] = new SelectList(service.GetSuppliers(), "SupplierID", "CompanyName", ViewData["SupplierID"] ?? product.SupplierID);

    return View("Edit", viewData);
}

public object Update(int id)
{
    Products product = service.GetProductById(id);

    if (!IsValid())
    {
    Request.Form.CopyTo(TempData);
    TempData["ErrorMessage"] = "An error occurred";
    return RedirectToAction("Edit", new { id = id });
    }

    BindingHelperExtensions.UpdateFrom(product, Request.Form);
    service.SubmitChanges(product);

    return RedirectToRoute(new RouteValueDictionary(new { Action = "List", ID = product.UpToCategoriesByCategoryID.CategoryName }));
}

And here are the methods from the newly refactored controller class.

public object Edit(int id)
{

    //ProductsEditViewData viewData = new ProductsEditViewData();
    Product product = service.GetProductById(id);
    //viewData.Product = product;

    if (TempData.ContainsKey("ErrorMessage"))
    {
    foreach (var item in TempData)
    {
        ViewData[item.Key] = item.Value;
    }
    }

    ViewData["CategoryID"] = new SelectList(service.GetCategories(), "CategoryID", "CategoryName", ViewData["CategoryID"] ?? product.CategoryID);
    ViewData["SupplierID"] = new SelectList(service.GetSuppliers(), "SupplierID", "CompanyName", ViewData["SupplierID"] ?? product.SupplierID);

    //return View("Edit", viewData);
    return View("Edit", product);
}

public object Update(int id)
{
    Product product = service.GetProductById(id);

    if (!IsValid())
    {
    Request.Form.CopyTo(TempData);
    TempData["ErrorMessage"] = "An error occurred";
    return RedirectToAction("Edit", new { id = id });
    }

    BindingHelperExtensions.UpdateFrom(product, Request.Form);
    service.SubmitChanges(product);

    return RedirectToRoute(new RouteValueDictionary(new { Action = "List", ID = product.Category.CategoryName }));
}

Notice that in the Edit method, I moved away from the ProductsEditViewData class to store the data and simply loaded the Product model class from the service.GetProductById(id) method.  Then I passed the product model to the View directly.

In the Update method, I had to change the RedirectToRoute line where the anonymous object was called using an Entity Spaces specific hierarchical jump to the CategoryName:

return RedirectToRoute(new RouteValueDictionary(new { Action = "List", ID = product.UpToCategoriesByCategoryID.CategoryName

I simply added a property to the Product model object that returns a Category model object and then I'm good to go.

return RedirectToRoute(new RouteValueDictionary(new { Action = "List", ID = product.Category.CategoryName }));

If you remember, the Product model class contains a property called Category, which returns a Category object.

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public class Product
    {
        public int ProductID { get; set; }
        public string ProductName { get; set; }
        public int SupplierID { get; set; }
        public int CategoryID { get; set; }
        public string QuantityPerUnit { get; set; }
        public decimal UnitPrice { get; set; }
        public int UnitsInStock { get; set; }
        public Category Category { get; set; }
        public Supplier Supplier { get; set; }
    }
}

This Category property is then populated way down in the NorthwindRepository class and the method, GetProductById(id).

/// <summary>
/// Get the product details by productid
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public Product GetProductById(int id)
{
    // Get the Products data from the database using Entity Spaces.
    Products prod = new Products();
    prod.LoadByPrimaryKey(id);

    // Instantiate the model Product object to store the
    // data from the Entity Spaces objects.
    Product product = new Product();
    product.ProductID = (int)prod.ProductID;
    product.ProductName = prod.ProductName;
    product.SupplierID = (int)prod.SupplierID;
    product.CategoryID = (int)prod.CategoryID;
    product.QuantityPerUnit = prod.QuantityPerUnit;
    product.UnitPrice = (decimal)prod.UnitPrice;
    product.UnitsInStock = (int)prod.UnitsInStock;

    // Load the Entity Spaces object to get the CompanyName.
    Suppliers supp = new Suppliers();
    supp.LoadByPrimaryKey(product.SupplierID);

    // New up a model Supplier object to store the CompanyName.
    product.Supplier = new Supplier() { CompanyName = supp.CompanyName };

    // Load the Entity Spaces Categories object to get the CategoryName.
    Categories cat = new Categories();
    cat.LoadByPrimaryKey(product.CategoryID);

    // New up the model Category object to store the CategoryName.
    product.Category = new Category() { CategoryName = cat.CategoryName };  // Category property populated here.

    // Return the model Product object.
    return product;
}

Ok, so that's what I did for this refactoring of the application.  I'm going to try a couple more things to this application, again as an exercise for myself. 

One is to try and implement Extension Methods (MSDN article msdn.microsoft.com/en-us/library/bb383977.aspx  and an article by Scott Guthrie weblogs.asp.net/scottgu/archive/2007/03/13/new-orcas-language-feature-extension-methods.aspx)  which can help make the application even more flexible and try to hook up SubSonic and see if this application above the Data layer holds up without making any changes to it.  That is the real test of extendibility and flexibility.

You can download the new version here. ESNorthwind.MVC_Pt2.zip (2.37 mb)

As always, if you have any questions or comments, good or bad, primarily good, then feel free to post a comment here or in my Forums.

Thanks.

Brand New Site about MVC

This site isn't about any specific MVC application, it's about any MVC application and to make them open source and available to developers.

I'm looking for interested participants to be a lead in the ongoing development of ASP.NET MVC applications.  If you are interested in leading a project, email me and I can give you access to the site to run your project.

Thanks,

King Wilder 

WHAT IS THIS?

This is an article about an ASP.NET MVC application I ported to use Entity Spaces as the data access layer, or model. 

Requirements:

• Northwind database - you need to have the Northwind database installed
• Entity Spaces - you'll need the trial version at least, of Entity Spaces to have this application work as is.

This doesn't mean that you can't learn something if you don't use Entity Spaces.  This exercise is to demonstrate how to build an ASP.NET MVC application without using Linq.

INSTALLATION

Installation instructions are at the end of this article.

ENTITY SPACES

Ok a brief word about Entity Spaces.  It is a really cool ORM tool but much more than that.  It reads your database and builds entity classes.  Now you might say that there are many tools that do that like NHibernate, SubSonic, etc., and you would be correct.  Entity Spaces actually costs money where SubSonic is free.  But I was using SubSonic before I trialed Entity Spaces.  After about a half a day playing with it, I purchased it and I'm going on my second year (2008) using it and I couldn't be happier.  Go to their web site to find out more.  But this article isn't about Entity Spaces, it's about building an ASP.NET MVC application without using Linq.

UPDATE to post  (6/3/2008):

Part Deux of this series will show you how to build the application to use any data layer provider instead of Entity Spaces.  Stay tuned...

SO...

I've been interested in MVC for ASP.NET ever since I heard about it about six months ago, primarily for the ease of testing and the separation of concerns.  So I decided to build (or port) an application using the ASP.NET MVC Preview 3 framework that was released at the end of May 2008.

I found a simple Northwind demo that Phil Haack put together and downloaded it so I could dissect it.  And this application like others I've downloaded all use the same data access method for their model, which is Linq, or more accurately, Linq to Sql.

Now I don't have anything against Linq, I just don't know it and I'm not sure I want to or need to.  I have Entity Spaces!  So after looking at the Northwind demo, I decided to take on the task of porting it over to use Entity Spaces to see if I have the right idea of what the model (and data access layer) does.  And to also see if I could do it.

<DISCLAIMER>
I am presenting this application to all those developers who do not presently know, or plan to know or use Linq.  I wanted to see how easy an ASP.NET MVC application can be built using a different data access provider and I built this in such a way so that developers can easily swap out my Entity Spaces provider with their own without ever touching the higher layers.

Also, I may have my head up my okole (Hawaiian for buttocks), so cut me some slack.
</DISCLAIMER>

The way I understand MVC is that the Model loosely translates to the data access layer of the application.  If I'm correct in this assumption, since no documentation seems to actually say "the Model is your data access layer", I just assume it is based on the description of what it does.  (For some reason everyone knowledgable of MVC assumes newbies will know what a Model is.  Unfortunately, I don't, or didn't.  I've never heard the term prior to hearing about MVC.  Vent!)

So based on my assumption, I rebuilt the application to not only try and integrate Entity Spaces as the Model part of this framework, but also build it using a psuedo-repository pattern in the data layer.  Let me be clear about this, I AM NO EXPERT in MVC or Design Patterns, although I did just finish the Head First Design Patterns book and I like what I read.

The repository pattern I'm following is one that is employed by Rob Conery in his new MVC Storefront real-world application.  So I jumped in the deep end and I decided to take on much more than I probably should have, but in the end it works and I was able to port the entire application in an afternoon.  (June 1, 2008 to be exact)

WHAT HAVE I DONE?

The original application was built using the default web site structure as created by Visual Studio, primarily one project.

I've built this application in four (4) projects:

• ESNorthwind.MVC.Web - the web site, controllers, and views, no models.
• ESNorthwind.MVC.Data - this is the Model project that contains the /Custom and /Generated folders for the Entity Spaces classes, Interfaces (INorthwindRepository) and Repository classes.
• ESNorthwind.MVC.Services - this contains the service layer that sits on top of the Data layer and is directly called from the Controller class.  This just adds another layer of abstraction.  (Does it sound like I'm talking out of my ass yet?)
• ESNorthwind.MVC.TestProjects - this contains unit tests that turns the only color that was available, which is green!

Also a note about NUnit, I used NUnit instead of the integrated Testing framework in Visual Studio 2008, for one specific reason... I have VS 2008 Standard which does not have the Unit Testing framework.  Ok, so I got the application for free from one of the Microsoft 2008 launches.  I can deal with that for a while.  Otherwise, I'm getting the same functionality I need for unit testing.

So back to my projects... I abstracted the application out like this for a few reasons:

1. I'm a glutton for punishment
2. I want to build a real-world MVC application using a pattern similar to this by not having the model in the web site project
3. I want to later see if I can easily change the data store to MySql instead of SQL Server, without affecting the rest of the application

WHAT DID I CHANGE?

Most of what I had to change, besides the overall structure of the application (four projects instead of one), was just the model or probably more precisely, the data access layer of the model.  (Again, my terminology might not be correct, so try not to flame me.  Just post a nice response indicating how wrong I am.)

I also removed all using statements that pointed to System.Linq.  I wanted to make sure that this application could live on it's own without any dependencies on Linq.

ALSO, this is the change that affected the biggest impact on whether it would work or not.  I had to change every reference from Products to Product, except of course the actual entity classes created by Entity Spaces.  The original demo application had a partial class called Product that it used as the reference for the model.  But my application was to use the ES Classes as the model which has a class called Products, which I found out was ambiguous to the compiler.

I wanted to try and build the application with out using any manufactured classes that would partial-ize an entity class.

So the Controller name is called ProductController (singular) not ProductsController.  It really was a pretty easy fix to implement site-wide, so it isn't really a problem.

VIEWS

The Views for the most part are as-is.  I did have to change a few things relationship-wise to take advantage of the Entity Spaces built-in relational mapping.

This is the Edit.aspx view in the original application:

<input type="submit" value="Save" /> <%= Html.ActionLink("cancel", "List", new { id = ViewData.Model.Product.Category.CategoryName })%>

And this is the same line of code in my version:

<input type="submit" value="Save" /> <%= Html.ActionLink("cancel", "List", new { id = ViewData.Model.Product.UpToCategoriesByCategoryID.CategoryName })%>

CONTROLLER

I also tried to move all or most of the data querying out of the Controller and move it into the Model where it belongs.

Here is some ProductsController code from the original application using Linq:

public class ProductsController : Controller {
        public ProductsController()
            : this(new NorthwindRepository(new NorthwindDataContext()))
        { }

        public ProductsController(NorthwindRepository context)
        {
            this.repository = context;
        }

        NorthwindRepository repository;

        public object Index()
        {
            return Categories();
        }

        public object Categories()
        {
            return View("Categories", repository.Categories.ToList());
        }

        public object Detail(int id)
        {
            Product product = this.repository.Products.SingleOrDefault(p => p.ProductID == id);
            return View(product);
        }

        public object List(string id)
        {
            var category = repository.Categories.SingleOrDefault(c => c.CategoryName == id);

            var products = from p in repository.Products
                           where p.CategoryID == category.CategoryID
                           select p;

            ViewData["Title"] = "Hello World!";
            ViewData["CategoryName"] = id;

            //this.ViewEngine = new MvcContrib.NHamlViewEngine.NHamlViewFactory();
            return View("ListingByCategory", products.ToList());
        }

        public object Category(int id)
        {
            Category category = repository.Categories.SingleOrDefault(c => c.CategoryID == id);
            return View("List", category);
        }

        public object Edit(int id)
        {
            ProductsEditViewData viewData = new ProductsEditViewData();

            Product product = repository.Products.SingleOrDefault(p => p.ProductID == id);
            viewData.Product = product;

            if (TempData.ContainsKey("ErrorMessage")) {
                foreach (var item in TempData) {
                    ViewData[item.Key] = item.Value;
                }
            }

            ViewData["CategoryID"] = new SelectList(repository.Categories.ToList(), "CategoryID", "CategoryName", ViewData["CategoryID"] ?? product.CategoryID);
            ViewData["SupplierID"]= new SelectList(repository.Suppliers.ToList(), "SupplierID", "CompanyName", ViewData["SupplierID"] ?? product.SupplierID);

            return View("Edit", viewData);
        }

        public object Update(int id)
        {
            Product product = repository.Products.SingleOrDefault(p => p.ProductID == id);
            if(!IsValid())
            {
                Request.Form.CopyTo(TempData);
                TempData["ErrorMessage"] = "An error occurred";
                return RedirectToAction("Edit", new { id = id });
            }

            BindingHelperExtensions.UpdateFrom(product, Request.Form);
            repository.SubmitChanges();

            return RedirectToRoute(new RouteValueDictionary(new { Action = "List", ID = product.Category.CategoryName }));
        }
....

And here is my new Controller code:

public class ProductController : Controller
    {
        NorthwindService service;

        #region Constructors

        public ProductController()
        {
            service = new NorthwindService();
        }
        
        #endregion

        #region View Methods

        public object Index()
        {
            return Categories();
        }

        public object Categories()
        {
            return View("Categories", service.GetCategories());
        }

        public object List(string id)
        {
            ViewData["CategoryName"] = id;

            return View("ListingByCategory", service.GetProductsByCategoryName(id));
        }

        public object Detail(int id)
        {
            return View("Detail", service.GetProductById(id));
        }

        public object Edit(int id)
        {

            ProductsEditViewData viewData = new ProductsEditViewData();
            Products product = service.GetProductById(id);
            viewData.Product = product;

            if (TempData.ContainsKey("ErrorMessage"))
            {
                foreach (var item in TempData)
                {
                    ViewData[item.Key] = item.Value;
                }
            }

            ViewData["CategoryID"] = new SelectList(service.GetCategories(), "CategoryID", "CategoryName", ViewData["CategoryID"] ?? product.CategoryID);
            ViewData["SupplierID"] = new SelectList(service.GetSuppliers(), "SupplierID", "CompanyName", ViewData["SupplierID"] ?? product.SupplierID);

            return View("Edit", viewData);
        }

        public object Update(int id)
        {
            Products product = service.GetProductById(id);

            if (!IsValid())
            {
                Request.Form.CopyTo(TempData);
                TempData["ErrorMessage"] = "An error occurred";
                return RedirectToAction("Edit", new { id = id });
            }

            BindingHelperExtensions.UpdateFrom(product, Request.Form);
            service.SubmitChanges(product);

            return RedirectToRoute(new RouteValueDictionary(new { Action = "List", ID = product.UpToCategoriesByCategoryID.CategoryName }));
        }


        #endregion

...
    }

Notice in my use of the Update method I have a SubmitChanges method on the service object, it's not part of Linq.  I just created it to maintain a similar feel to Linq, but I had to pass in the Products object to the method as an argument in order for it to get updated correctly.  Now bear in mind that there is most likely a better way of doing this, but this is what I did.  You can change it to anything you feel works as good or better.  Let me know what you did though, I'd be interested in hearing what you came up with.

But you'll notice that most of my service calls provide the same functionality as those from the original demo without having any querying in the controller itself.

Now as the application gets more complex, I don't know how far I would be able to take this, but at least I was able to do it this far.
   
GLOBAL ASAX

This is the original application:

protected void Application_Start(object sender, EventArgs e)
{
    RegisterRoutes(RouteTable.Routes);
}

And this is my version:

protected void Application_Start()
{
    RegisterRoutes(RouteTable.Routes);
    EntitySpaces.Interfaces.esProviderFactory.Factory = new EntitySpaces.LoaderMT.esDataProviderFactory();
}

DATABASE CHANGES

There was a small change I had to make to the Northwind database itself in order for the routing to work.  There are two categories, Grains/Cereals and Meat/Poultry.  If you know about routing, the forward slashes will present a problem, so I had to change the fields in the database to use dashes instead, Grains-Cereals, etc.  Then it works without a problem.

Other than that, no changes to the database.


SERVICE LAYER

The service layer is essentially a relay object to the data layer.  It allows for more of a separation of concerns, meaning it is easier this way, to snap-in a different provider without affecting the Web layer.

The code for the service layer is pretty straight forward:

using System;
using System.Collections.Generic;
using System.Text;
using ESNorthwind.MVC.Data;

namespace ESNorthwind.MVC.Services
{
    public class NorthwindService
    {
        INorthwindRepository _repository = null;

        #region Constructors
        public NorthwindService(INorthwindRepository repository)
        {
            this._repository = repository;
            if (_repository == null)
                throw new InvalidOperationException("Repository cannot be null");
        }
        public NorthwindService()
        {
            this._repository = new NorthwindRepository();
        }
        #endregion

        #region Public Methods

        /// <summary>
        /// Get all the categories.
        /// </summary>
        /// <returns></returns>
        public CategoriesCollection GetCategories()
        {
            CategoriesCollection catColl = _repository.GetCategories();
            return catColl;
        }

        /// <summary>
        /// Get all products.
        /// </summary>
        /// <returns></returns>
        public ProductsCollection GetProducts()
        {
            ProductsCollection prodColl = _repository.GetProducts();
            return prodColl;
        }

        /// <summary>
        /// Return the ProductsCollection based on the Category name.
        /// </summary>
        /// <param name="categoryName"></param>
        /// <returns></returns>
        public ProductsCollection GetProductsByCategoryName(string categoryName)
        {
            ProductsCollection prodColl = _repository.GetProductsByCategoryName(categoryName);
            return prodColl;
        }

        /// <summary>
        /// Return the product based on the product id.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public Products GetProductById(int id)
        {
            Products product = _repository.GetProductById(id);
            return product;
        }

        /// <summary>
        /// Get all suppliers.
        /// </summary>
        /// <returns></returns>
        public SuppliersCollection GetSuppliers()
        {
            return _repository.GetSuppliers();
        }

        public void SubmitChanges(Products product)
        {
            _repository.SubmitChanges(product);
        }
        #endregion
    }
}

Another thing I wanted to see if I could do with this application, is to avoid using IQueryable, which is a Linq interface.  Knowing as little as I did (and still do) about ASP.NET MVC, I really didn't know whether I could build and MVC application without using IQueryable. 

I really wanted to use the Collection classes created by Entity Spaces instead of IQueryable, so I wrote a few tests and saw that it worked.  Needless to say I was jazzed.

DATA LAYER

The first thing I did was create an interface the repository was to implement, INorthwindRepository.

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public interface INorthwindRepository
    {
        CategoriesCollection GetCategories();
        ProductsCollection GetProducts();
        ProductsCollection GetProductsByCategoryName(string categoryName);
        Products GetProductById(int id);
        SuppliersCollection GetSuppliers();
        void SubmitChanges(Products product);
    }
}

A quick aside... I've been reading everything I can about OOP and Design Patterns, etc., to better my knowledge of making scalable and reusable applications.  I've always known about interfaces, but I have never been really clear about why they are in existence and why I should use them.

But after reading books like the Head First Design Patterns, and Head First Object Oriented Analysis and Design, I feel I have a better understanding of what their purpose in life is.

Now back to our story...

By creating a repository that implements INorthwindRepository, the service layer will accept the repository without any complaints whether it's using MySql, SQL Server, Oracle, etc.

"Code to an Interface, not an implementation!"

So the NorthwindRepository class implements this interface and does all the heavy lifting.

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public class NorthwindRepository : INorthwindRepository
    {
        #region INorthwindRepository Members

        /// <summary>
        /// Get all categories.
        /// </summary>
        /// <returns></returns>
        public CategoriesCollection GetCategories()
        {
            CategoriesCollection catColl = new CategoriesCollection();
            catColl.LoadAll();
            return catColl;
        }

        /// <summary>
        /// Get all products.
        /// </summary>
        /// <returns></returns>
        public ProductsCollection GetProducts()
        {
            ProductsCollection prodColl = new ProductsCollection();
            prodColl.LoadAll();
            return prodColl;
        }

        /// <summary>
        /// Return the ProductsCollection by the Category name.
        /// </summary>
        /// <param name="categoryName"></param>
        /// <returns></returns>
        public ProductsCollection GetProductsByCategoryName(string categoryName)
        {
            int catId = 0;

            Categories cat = new Categories();
            cat.Query.Where(cat.Query.CategoryName.Equal(categoryName));
            cat.Query.Load();
            catId = (int)cat.CategoryID;

            ProductsCollection prodColl = new ProductsCollection();
            prodColl.Query.Where(prodColl.Query.CategoryID.Equal(catId));
            prodColl.Query.Load();
            return prodColl;
        }

        /// <summary>
        /// Get the product details by productid
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public Products GetProductById(int id)
        {
            Products product = new Products();
            product.LoadByPrimaryKey(id);
            return product;
        }

        /// <summary>
        /// Get all suppliers.
        /// </summary>
        /// <returns></returns>
        public SuppliersCollection GetSuppliers()
        {
            SuppliersCollection suppColl = new SuppliersCollection();
            suppColl.LoadAll();
            return suppColl;
        }

        public void SubmitChanges(Products product)
        {
            product.Save();
        }

        #endregion
    }
}

Again, it's not all that complex since this is a simple application, but you get the idea of how this works.  This is the class that creates the concrete Entity Spaces classes that will return data to the service layer.

The only other class I have in this layer is a helper class for Views that need data from more than one entity.

using System;
using System.Collections.Generic;
using System.Text;

namespace ESNorthwind.MVC.Data
{
    public class ProductsEditViewData
    {
        public Products Product { get; set; }
        public SuppliersCollection Suppliers { get; set; }
        public CategoriesCollection Categories { get; set; }
    }

    public class ProductsNewViewData
    {
        public SuppliersCollection Suppliers { get; set; }
        public CategoriesCollection Categories { get; set; }
    } 
}

This is shoved into the code-behind of the Edit.aspx view to transport data to the view.

using System;
using System.Web;
using System.Web.Mvc;
using ESNorthwind.MVC.Data;

namespace ESNorthwind.MVC.Web.Views.Products
{
    public partial class Edit : ViewPage<ProductsEditViewData>
    {
    }
}

In the Controller class, the Edit method uses this class that passes it along to the aspx page.

public object Edit(int id)
{

    ProductsEditViewData viewData = new ProductsEditViewData();
    Products product = service.GetProductById(id);
    viewData.Product = product;

    if (TempData.ContainsKey("ErrorMessage"))
    {
    foreach (var item in TempData)
    {
        ViewData[item.Key] = item.Value;
    }
    }

    ViewData["CategoryID"] = new SelectList(service.GetCategories(), "CategoryID", "CategoryName", ViewData["CategoryID"] ?? product.CategoryID);
    ViewData["SupplierID"] = new SelectList(service.GetSuppliers(), "SupplierID", "CompanyName", ViewData["SupplierID"] ?? product.SupplierID);

    return View("Edit", viewData);
}

So that's about it.  Feel free to comb through the code to see what I did and remember, I don't really know what I'm doing.  So if you like this application, my name is King Wilder.  If you don't, my name is John Smith.

I've been watching every video I can on the subject from Rob Conery, Scott Guthrie and Scott Hanselman, and I'm amazed at how lost I can get watching them sometimes.  But other times I have a clarity that is overwhelming.  I'd like to think this is one of those moments.

Thanks and if you have any comments, you can post them here, or in the Forums.

INSTALLATION

Click this link to download the application. ESNorthwind.MVC.zip (2.27 mb)

For Entity Spaces Users:

• simply unzip the application then add a reference to all the Entity Spaces DLL's to all four projects and generate the Custom and Generated classes to the Data project.  Compile.

For non-Entity Spaces users:

• You must download the trial version of Entity Spaces and create the files necessary to run the application.  You can find these instructions on the Entity Spaces web site.  www.entityspaces.net

If you have any questions or comments you can post them here on the Blog or post your comment in the Forums, click on the Forums link at the top of this page.

Thanks.