A few days ago, I gave a talk on building Single Page Apps on
the Microsoft Stack. In that talk, I recommended that people use Knockout, Sammy, and RequireJS to build their presentation layer and use
the ASP.NET Web API to expose data from their server.
After I gave
the talk, several people contacted me and suggested that I investigate a new open-source JavaScript library named Durandal. Durandal stitches together Knockout, Sammy, and RequireJS to make it easier to use these technologies together.
In this blog entry, I want to provide a brief walkthrough of using Durandal to create a simple Single Page App. I am going to demonstrate how you can create a simple Movies App which contains (virtual) pages for viewing a list of movies, adding new movies, and viewing movie details.
The goal of this blog entry is to give you a sense of what it is like to build apps with Durandal.
Installing Durandal
First things first. How do you get Durandal?
The GitHub project for Durandal is located here:
https://github.com/BlueSpire/Durandal
The Wiki — located at
the GitHub project — contains all of
the current documentation for Durandal. Currently,
the documentation is a little sparse, but it is enough to get you started.
Instead of downloading
the Durandal source from GitHub, a better option for getting started with Durandal is to install one of
the Durandal NuGet packages.
I built
the Movies App described in this blog entry by first creating a new ASP.NET MVC 4 Web Application with
the Basic Template. Next, I executed
the following command from
the Package Manager Console:
Install-Package Durandal.StarterKit
As you can see from
the screenshot of
the Package Manager Console above,
the Durandal Starter Kit package has several dependencies including:
· jQuery
· Knockout
· Sammy
· Twitter Bootstrap
The Durandal Starter Kit package includes a sample Durandal application. You can get to
the Starter Kit app by navigating to
the Durandal controller.
Unfortunately, when I first tried to run
the Starter Kit app, I got an error because
the Starter Kit is hard-coded to use a particular version of jQuery which is already out of date. You can fix this issue by modifying
the App_Start\DurandalBundleConfig.cs file so it is jQuery version agnostic like this:
bundles.Add(
new ScriptBundle("~/scripts/vendor")
.Include("~/Scripts/jquery-{version}.js")
.Include("~/Scripts/knockout-{version}.js")
.Include("~/Scripts/sammy-{version}.js")
// .Include("~/Scripts/jquery-1.9.0.min.js")
// .Include("~/Scripts/knockout-2.2.1.js")
// .Include("~/Scripts/sammy-0.7.4.min.js")
.Include("~/Scripts/bootstrap.min.js")
);
The recommendation is that you create a Durandal app in a folder off your project root named App.
The App folder in
the Starter Kit contains
the following subfolders and files:
· durandal – This folder contains
the actual durandal JavaScript library.
· viewmodels – This folder contains all of your application’s view models.
· views – This folder contains all of your application’s views.
· main.js — This file contains all of
the JavaScript startup code for your app including
the client-side routing configuration.
· main-built.js – This file contains an optimized version of your application. You need to build this file by using
the RequireJS optimizer (unfortunately, before you can run
the optimizer, you must first install NodeJS).
For
the purpose of this blog entry, I wanted to start from scratch when building
the Movies app, so I deleted all of these files and folders except for
the durandal folder which contains
the durandal library.
Creating
the ASP.NET MVC Controller and View
A Durandal app is built using a single server-side ASP.NET MVC controller and ASP.NET MVC view. A Durandal app is a Single Page App. When you navigate between pages, you are not navigating to new pages on
the server. Instead, you are loading new virtual pages into
the one-and-only-one server-side view.
For
the Movies app, I created
the following ASP.NET MVC Home controller:
public class HomeController : Controller {
public ActionResult Index() {
return View();
}
}
There is nothing special about
the Home controller – it is as basic as it gets.
Next, I created
the following server-side ASP.NET view. This is
the one-and-only server-side view used by
the Movies app:
@{
Layout = null;
}
<!DOCTYPE html>
<html>
<head>
<title>Index</title>
</head>
<body>
<div id="applicationHost">
Loading app....
</div>
@Scripts.Render("~/scripts/vendor")
<script type="text/javascript" src="~/App/durandal/amd/require.js"
data-main="/App/main"></script>
</body>
</html>
Notice that I set
the Layout property for
the view to
the value null. If you neglect to do this, then
the default ASP.NET MVC layout will be applied to
the view and you will get
the <!DOCTYPE> and opening and closing <html> tags twice.
Next, notice that
the view contains a DIV element with
the Id applicationHost. This marks
the area where virtual pages are loaded. When you navigate from page to page in a Durandal app, HTML page fragments are retrieved from
the server and stuck in
the applicationHost DIV element.
Inside
the applicationHost element, you can place
any content which you want to display when a Durandal app is starting up. For example, you can create a fancy splash screen. I opted for simply displaying
the text “Loading app…”:
Next, notice
the view above includes a call to
the Scripts.Render() helper. This helper renders out all of
the JavaScript files required by
the Durandal library such as jQuery and Knockout. Remember to fix
the App_Start\DurandalBundleConfig.cs as described above or Durandal will attempt to load an old version of jQuery and throw a JavaScript exception and stop working.
Your application JavaScript code is not included in
the scripts rendered by
the Scripts.Render helper. Your application code is loaded dynamically by RequireJS with
the help of
the following SCRIPT element located at
the bottom of
the view:
<script type="text/javascript" src="~/App/durandal/amd/require.js"
data-main="/App/main"></script>
The data-main attribute on
the SCRIPT element causes RequireJS to load your /app/main.js JavaScript file to kick-off your Durandal app.
Creating
the Durandal Main.js File
The Durandal Main.js JavaScript file, located in your App folder, contains all of
the code required to configure
the behavior of Durandal. Here’s what
the Main.js file looks like in
the case of
the Movies app:
require.config({
paths: {
'text': 'durandal/amd/text'
}
});
define(function (require) {
var app = require('durandal/app'),
viewLocator = require('durandal/viewLocator'),
system = require('durandal/system'),
router = require('durandal/plugins/router');
//>>excludeStart("build", true);
system.debug(true);
//>>excludeEnd("build");
app.start().then(function () {
//Replace 'viewmodels' in
the moduleId with 'views' to locate
the view.
//Look for partial views in a 'views' folder in
the root.
viewLocator.useConvention();
//configure routing
router.useConvention();
router.mapNav("movies/show");
router.mapNav("movies/add");
router.mapNav("movies/details/:id");
app.adaptToDevice();
//Show
the app by setting
the root view model for our application with a transition.
app.setRoot('viewmodels/shell', 'entrance');
});
});
There are three important things to notice about
the main.js file above. First, notice that it contains a section which enables debugging which looks like this:
//>>excludeStart(“build”, true);
system.debug(true);
//>>excludeEnd(“build”);
This code enables debugging for your Durandal app which is very useful when things go wrong. When you call system.debug(true), Durandal writes out debugging information to your browser JavaScript console. For example, you can use
the debugging information to diagnose issues with your client-side routes:
(The funny looking //> symbols around
the system.debug() call are RequireJS optimizer pragmas).
The main.js file is also
the place where you configure your client-side routes. In
the case of
the Movies app,
the main.js file is used to configure routes for three page:
the movies show, add, and details pages.
//configure routing
router.useConvention();
router.mapNav("movies/show");
router.mapNav("movies/add");
router.mapNav("movies/details/:id");
The route for movie details includes a route parameter named id. Later, we will use
the id parameter to lookup and display
the details for
the right movie.
Finally,
the main.js file above contains
the following line of code:
//Show
the app by setting
the root view model for our application with a transition.
app.setRoot('viewmodels/shell', 'entrance');
This line of code causes Durandal to load up a JavaScript file named shell.js and an HTML fragment named shell.html. I’ll discuss
the shell in
the next section.
Creating
the Durandal Shell
You can think of
the Durandal shell as
the layout or master page for a Durandal app.
The shell is where you put all of
the content which you want to remain constant as a user navigates from virtual page to virtual page. For example,
the shell is a great place to put your website logo and navigation links.
The Durandal shell is composed from two parts: a JavaScript file and an HTML file. Here’s what
the HTML file looks like for
the Movies app:
<h1>Movies App</h1>
<div class="container-fluid page-host">
<!--ko compose: {
model: router.activeItem, //wiring
the router
afterCompose: router.afterCompose, //wiring
the router
transition:'entrance', //use
the 'entrance' transition when switching views
cacheViews:true //telling composition to keep views in
the dom, and reuse them (only a good idea with singleton view models)
}--><!--/ko-->
</div>
And here is what
the JavaScript file looks like:
define(function (require) {
var router = require('durandal/plugins/router');
return {
router: router,
activate: function () {
return router.activate('movies/show');
}
};
});
The JavaScript file contains
the view model for
the shell. This view model returns
the Durandal router so you can access
the list of configured routes from your shell.
Notice that
the JavaScript file includes a function named activate(). This function loads
the movies/show page as
the first page in
the Movies app. If you want to create a different default Durandal page, then pass
the name of a different age to
the router.activate() method.
Creating
the Movies Show Page
Durandal pages are created out of a view model and a view.
The view model contains all of
the data and view logic required for
the view.
The view contains all of
the HTML markup for rendering
the view model.
Let’s start with
the movies show page.
The movies show page displays a list of movies.
The view model for
the show page looks like this:
define(function (require) {
var moviesRepository = require("repositories/moviesRepository");
return {
movies: ko.observable(),
activate: function() {
this.movies(moviesRepository.listMovies());
}
};
});
You create a view model by defining a new RequireJS module (see http://requirejs.org). You create a RequireJS module by placing all of your JavaScript code into an anonymous function passed to
the RequireJS define() method.
A RequireJS module has two parts. You retrieve all of
the modules which your module requires at
the top of your module.
The code above depends on another RequireJS module named repositories/moviesRepository.
Next, you return
the implementation of your module.
The code above returns a JavaScript object which contains a property named movies and a method named activate.
The activate() method is a magic method which Durandal calls whenever it activates your view model. Your view model is activated whenever you navigate to a page which uses it. In
the code above,
the activate() method is used to get
the list of movies from
the movies repository and assign
the list to
the view model movies property.
The HTML for
the movies show page looks like this:
<table>
<thead>
<tr>
<th>Title</th><th>Director</th>
</tr>
</thead>
<tbody data-bind="foreach:movies">
<tr>
<td data-bind="text:title"></td>
<td data-bind="text:director"></td>
<td><a data-bind="attr:{href:'#/movies/details/'+id}">Details</a></td>
</tr>
</tbody>
</table>
<a href="#/movies/add">Add Movie</a>
Notice that this is an HTML fragment. This fragment will be stuffed into
the page-host DIV element in
the shell.html file which is stuffed, in turn, into
the applicationHost DIV element in
the server-side MVC view.
The HTML markup above contains data-bind attributes used by Knockout to display
the list of movies (To learn more about Knockout, visit http://knockoutjs.com).
The list of movies from
the view model is displayed in an HTML table.
Notice that
the page includes a link to a page for adding a new movie.
The link uses
the following URL which starts with a hash: #/movies/add. Because
the link starts with a hash, clicking
the link
does not cause a request back to
the server. Instead, you navigate to
the movies/add page virtually.
Creating
the Movies Add Page
The movies add page also consists of a view model and view.
The add page enables you to add a new movie to
the movie database.
Here’s
the view model for
the add page:
define(function (require) {
var app = require('durandal/app');
var router = require('durandal/plugins/router');
var moviesRepository = require("repositories/moviesRepository");
return {
movieToAdd: {
title: ko.observable(),
director: ko.observable()
},
activate: function () {
this.movieToAdd.title("");
this.movieToAdd.director("");
this._movieAdded = false;
},
canDeactivate: function () {
if (this._movieAdded == false) {
return app.showMessage('Are you sure you want to leave this page?', 'Navigate', ['Yes', 'No']);
} else {
return true;
}
},
addMovie: function () {
// Add movie to db
moviesRepository.addMovie(ko.toJS(this.movieToAdd));
// flag new movie
this._movieAdded = true;
// return to list of movies
router.navigateTo("#/movies/show");
}
};
});
The view model contains one property named movieToAdd which is bound to
the add movie form.
The view model also has
the following three methods:
1. activate() – This method is called by Durandal when you navigate to
the add movie page.
The activate() method resets
the add movie form by clearing out
the movie title and director properties.
2. canDeactivate() – This method is called by Durandal when you attempt to navigate away from
the add movie page. If you return false then navigation is cancelled.
3. addMovie() – This method executes when
the add movie form is submitted. This code adds
the new movie to
the movie repository.
I really like
the Durandal canDeactivate() method. In
the code above, I use
the canDeactivate() method to show a warning to a user if they navigate away from
the add movie page – either by clicking
the Cancel button or by hitting
the browser back button – before submitting
the add movie form:
The view for
the add movie page looks like this:
<form data-bind="submit:addMovie">
<fieldset>
<legend>Add Movie</legend>
<div>
<label>
Title:
<input data-bind="value:movieToAdd.title" required />
</label>
</div>
<div>
<label>
Director:
<input data-bind="value:movieToAdd.director" required />
</label>
</div>
<div>
<input type="submit" value="Add" />
<a href="#/movies/show">Cancel</a>
</div>
</fieldset>
</form>
I am using Knockout to bind
the movieToAdd property from
the view model to
the INPUT elements of
the HTML form. Notice that
the FORM element includes a data-bind attribute which invokes
the addMovie() method from
the view model when
the HTML form is submitted.
Creating
the Movies Details Page
You navigate to
the movies details Page by clicking
the Details link which appears next to each movie in
the movies show page:
The Details links pass
the movie ids to
the details page:
#/movies/details/0
#/movies/details/1
#/movies/details/2
Here’s what
the view model for
the movies details page looks like:
define(function (require) {
var router = require('durandal/plugins/router');
var moviesRepository = require("repositories/moviesRepository");
return {
movieToShow: {
title: ko.observable(),
director: ko.observable()
},
activate: function (context) {
// Grab movie from repository
var movie = moviesRepository.getMovie(context.id);
// Add to view model
this.movieToShow.title(movie.title);
this.movieToShow.director(movie.director);
}
};
});
Notice that
the view model activate() method accepts a parameter named context. You can take advantage of
the context parameter to retrieve route parameters such as
the movie Id.
In
the code above,
the context.id property is used to retrieve
the correct movie from
the movie repository and
the movie is assigned to a property named movieToShow exposed by
the view model.
The movie details view displays
the movieToShow property by taking advantage of Knockout bindings:
<div>
<h2 data-bind="text:movieToShow.title"></h2>
directed by <span data-bind="text:movieToShow.director"></span>
</div>
Summary
The goal of this blog entry was to walkthrough building a simple Single Page App using Durandal and to get a feel for what it is like to use this library. I really like how Durandal stitches together Knockout, Sammy, and RequireJS and establishes patterns for using these libraries to build Single Page Apps.
Having a standard pattern which developers on a team can use to build new pages is super valuable. Once you get
the hang of it, using Durandal to create new virtual pages is dead simple. Just define a new route, view model, and view and you are done.
I also appreciate
the fact that Durandal did not attempt to re-invent
the wheel and that Durandal leverages existing JavaScript libraries such as Knockout, RequireJS, and Sammy. These existing libraries are powerful libraries and I have already invested a considerable amount of time in learning how to use them. Durandal makes it easier to use these libraries together without losing
any of their power.
Durandal has some additional interesting features which I have not had a chance to play with yet. For example, you can use
the RequireJS optimizer to combine and minify all of a Durandal app’s code. Also, Durandal supports a way to create custom widgets (client-side controls) by composing widgets from a controller and view.
You can download
the code for
the Movies app by clicking
the following link (this is a Visual Studio 2012 project):
Durandal Movie App
