Aug 08 2009
How-To: Using the N* stack, part 1
This is the first post in a series where I show you step-by-step how to get your first ASP.NET MVC website up off the ground. By the end of this series, we’ll have a working web application for registering community college students. More importantly, you'll have a template you can easily follow for your own projects. In this first post, I’ll show you how to set up your visual studio solution. In this series, we’ll use these tools:
- ASP.NET MVC is a free, fully Microsoft-supported product that, unlike ASP.NET WebForms, gives you complete control over your application. You can use the Web Platform Installer or download the MSI installer package directly.
- MVCContrib – This is the contrib project for ASP.NET MVC. It adds additional functionality to and makes ASP.NET MVC easier to use.
- NHibernate 2,1 is a well-known, mature, open source object relational mapper (ORM). It helps you get on with writing you application, instead of spending days, weeks, or even months writing a data access layer.
- Fluent NHibernate – This is a library for configuring NHibernate using an english-like syntax. It saves you from hacking through dozens of XML configuration files. Scroll to the bottom of the downloads page and get the latest compiled binaries.
- Ninject is my personal favorite dependency injection (DI) / inversion of control (IoC) framework. It allows you to automatically wire up services to your objects. If you’ve never done DI or IoC before, you’re going to have a great “ah-ha!” moment. We’ll be using version 1.
- .NET Framework 3.5 SP1
- Visual Studio 2008 SP1. The Web Dev Express version may also work. I haven’t tried it.
- The latest version of NUnit
- Any major database supported by NHibenate. This can range from Oracle to SQL Server to MySQL to SQLite. I’ll be using SQL server in my examples, but if you have a favorite, you can easily use that instead.
- MVC stands for Model-View-Controller. This separation of responsibilities allows you greater flexibility to adapt and change your application.
- Model – This term refers to all of your entities – your business objects. In terms of a billing application, this would be your invoices, invoice items, customers, products, etc. – all of the “real-world things” your application represents.
- View – Each view presents a specific business object in a specific way. For example, you may have a view for editing customer data and another for displaying an invoice. You can also think of views as the pages that make up your application.
- Controller – Controllers are the glue that bind a view to a specific entity in your model. They are also responsible for all of the flow of your application from page to page.
- Inversion of Control (IoC) is the concept that your objects do not explicitly create the services that they need. Instead, they get them from some container of services. Hence, the inversion. Your classes don’t specify a specific implementation of the service, only the type of service they need – an interface. This loose coupling allows you to easily swap out implementations of those services without having to touch every class that uses them. I’ve seen two major flavors of IoC: Service Locator and Dependency Injection.
- A Service Locator is a central container where you specify which implementations of each service your application will use. Your objects request service implementations from the service locator. A service locator is typically a singleton, which is why I don’t like it.
- Dependency Injection (DI) is a method of wiring your objects to the services they depend on as the object is built. These services are typically passed in as parameters on the object’s constructor. The object itself is built by the DI framework, in this case, Ninject. The process of building dependencies can be many layers deep. The Ninject Dojo has a great tutorial on dependency injection. If you’re new to IoC, it’s a great place to start learning. Once you have the “ah ha!” moment, the migraine will stop and you’ll never look at code the same again. I promise.
Setting up the solutionDisclaimer: This is how I have learned to set up my projects. I’m sure others have differing opinions. I’d love to hear them. I don’t claim to be an expert, just a curious professional looking to improve. Setting up the project is fairly straight-forward. We’ll do almost everything through Visual Studio. Just follow these steps.
Create the solution and web projectIn Visual Studio, start a new ASP.NET MVC Web Application. This template is added to Visual Studio when you install ASP.NET MVC. I’ll be calling my solution NStackExample. There’s a few things to note here. First, we’re creating a solution directory. Second, notice how we’ve appended .Web to the name of our web project, but not the solution. This web project will contain all of the views. Despite the implied direction from Microsoft through the ASP.NET MVC template, it won’t contain the model or the controllers.
Create a library directoryInside your solution directory, create a directory for all 3rd party libraries used in your project. I call mine Solution Items. The name you give it isn’t as important as the fact that you have one. So, in the example shown above, I would create the directory C:UsersJasonDocumentsVisual Studio 2008ProjectsNStackExampleSolution items. Copy these 15 assemblies to the library directory:
- From MVCContrib:
- From NHibernate:
- FluentNHibernate.dll from Fluent NHibernate
- From Ninject:
- From MVCContrib:
Create the core projectThis is your main project. It will contain your model, as well as interfaces for any services and strategies your application will use. It will not contain the implementation of any of those services. Those go in separate, easily replaceable assemblies. Add a new “Class Library” project to your solution. We’ll call this project NStackExample.Core. Now, right click on the project and select properties, then click on the Application tab on the side. In the root namespace field, remove .Core. We’re doing this so our entities will be named NStackExample.Entity1, NStackExample.Entity2, etc. but the assembly will be NStackExample.Core.dll, which better describes it’s purpose.
Create the controller projectNext, create another project specifically for the controllers of your MVC project. We’re going to call it NStackExample.Controllers. Yes, the Microsoft ASP.NET MVC project template already has a folder for them. We’re not going to use that folder because I think they should be better separated from the content of your website.
Clean up your projectsDelete all of these:
- The Class.vb or Class.cs files in the Core and Controllers projects.
- In the NStackExample.Web project, delete:
- The Controllers folder and all of it's contents.
- The Models folder
- The Microsoft AJAX script libraries in the Scripts folder
- The Home and Account folders inside the Views folder
- The LogOnUserControl in the Views folder
Set up your referencesThis is pretty straight forward.
- First, in your web project, remove the references to System.Web.Abstractions, System.Web.Mvc, and System.Web.Routing.
- Next, in your web project, from the library directory we created in step 2, add references to these 10 assemblies:
- In the web project, add references to the controllers project and the core project.
- In the controllers project, add references to these 3 assemblies:
- In the controllers project, add a reference to the core project.