S#arp Architecture¶

Tasks¶

Previous known as “Application Services,” the Tasks Layer serves to tie together any non-business logic from a variety of third-party services or persistence technologies. While setup and defining a service such as Twitter would occur in the Infrastructure Layer, executing and combining the results with, say, a local NHibernate database, would occur in the Tasks Layer. The resulting viewModel or DTO would be sent down to the Presentation Layer

Presentation¶

The Presentation Layer contains the familiar MVC project with views, viewmodels and controllers, along with application setup tasks. Previous iterations of Sharp Architecture spun out controllers to a separate application, but as of 2.0 this is no longer the case.

Infrastructure¶

The Infrastructure Layer setups up third party data sources, along with items such as NHibernate maps. You can extend the repository implementation with additional methods to perform specific queries, but it is recommended to write your own Query Objects as shown in the cookbook.

Domain¶

The Domain Layer is where business entities and other business logic resides. The domain layer should be persistence ignorant, with any persistence existing in the Tasks Layer or in the Presentation Layer (for populating viewModels).

Deploy Sharp Architecture with Templify¶

Download and install Templify. Make sure to install the latest Sharp Architecture package by going to the Sharp Architecture Downloads page and downloading the Templify zip required, currently there are templates for NHibernate and RavenDB.

Extract the contents and run the *.cmd file to install the package.

Next, select the folder you wish to deploy Sharp Architecture. In our case, let’s create a folder and name the project, IceCreamYouScreamCorp. After Templify has finished deploying the package, go ahead and launch the solution in Visual Studio.

Using Nuget¶

TODO

Create your first entity¶

Let’s jump back over to our Visual Studio solution. Navigate to your Domain project and define a class called Product that inherits from Entity. All domain objects that are persisted in Sharp inherit from this base class. Entity does many things, but for the purposes of this example we only care about the fact that:

• The property Id is already set for us.
• We are now inheriting a ValidatableObject, which gives us the IsValid() method.

Due to NHibernate, all properties must be marked virtual. We’ll only have one property for this class, a string titled Name. When you’re done, your class should look like this:

namespace IceCreamYouScreamCorp.Domain
{
    using System;
    using System.ComponentModel.DataAnnotations;

    using SharpArch.Domain.DomainModel;

    public class Product : Entity
    {
        [Required(ErrorMessage = "Must have a clever name!")]
        public virtual string Name { get; set; }
    }
}

Configure NHibernate.config¶

You can skip this step if you are using RavenDB persistance.

Before we go any further, navigate to your Mvc project and find NHibernate.config. I’m assuming you’re running a local instance of SQL Express with a database named IceCreamDb. You’ll need to figure out your own connection string, but once you do, find the “connection.connection_string” tags:

<property name="connection.connection_string">Server=localhost\SQLEXPRESS;Initial Catalog=IceCreamDb;Integrated Security=SSPI;</property>

Prep your database environment¶

You can skip this step if you are using RavenDB persistance.

Before we start we’ll need to wire up NHibernate to your database. If you have not already done so, create a database. Let’s assume you have SQLExpress running on your local machine and you’ve created a database called IceCreamDb.

Run the test IceCreamYouScreamCorp.Tests.SharpArchTemplate.Data.NHibernateMaps.CanGenerateDatabaseSchema which will generate a script for creating the database in the Database folder under the folder you templified.

Alternatively, run the IceCreamYouScreamCorp.Tests.SharpArchTemplate.Data.NHibernateMaps.CanCreateDatabase test which will create the tables for you. This test is set to run explictly to avoid overwriting existing tables.

Create a Controller¶

Create a controller in your controllers folder named ProductsController.

NB: In this example we’re injecting repositories into our controllers. This is not recommended best practice. Please see the Cookbook example for abstracting this to your Tasks layer. I think for the purposes of this example, it is much more clear to inject the Repository.

NB + 1: Sharp Architecture uses dependency injection, the “Don’t call us, we’ll call you,” principle. Dependency injection is a bit out of the scope of the article. If this is new to you, I highly recommend looking at Martin Fowler’s article.

One of the great things about Sharp Architecture is that it has created a generic repository for you. Generally there’s no need to worry about the NHibernate session, or creating a specific repository each time you need to talk to your database. As such, let’s create a local field, private readonly INHibernateRepository<Product> productRepository; and inject it into our controller:

public ProductsController(INHibernateRepository<Product> productRepository)
{
   this.productRepository = productRepository;
}

Create ActionResults for our Crud Operations¶

Now we’re all setup let’s we’ll need to do the following things:

• Return a list of all products
• Return a single product
• Create/Update a single product
• Delete a product

Returning all products on the Index ActionResult:

public ActionResult Index()
{
   var products = this.productRepository.GetAll();
   return View(products);
}

Return a single product and display it on an editable form:

[Transaction]
[HttpGet]
public ActionResult CreateOrUpdate(int id)
{
    var product = this.productRepository.Get(id);
    return View(product);
}

Post the result, return the object if it is invalid:

[Transaction]
[ValidateAntiForgeryToken]
[HttpPost]
public ActionResult CreateOrUpdate(Product product)
{
    if (ModelState.IsValid && product.IsValid())
    {
        this.productRepository.SaveOrUpdate(product);
        return this.RedirectToAction("Index");
    }

    return View(product);
}

Delete a product, making sure we are posting as we are changing data.

[Transaction]
[ValidateAntiForgeryToken]
[HttpPost]
public ActionResult Delete(int id)
{
    var product = this.productRepository.Get(id);

    if (product == null)
    {
        return HttpNotFound();
    }

    this.productRepository.Delete(product);
    return this.RedirectToAction("Index");
}

Add the views¶

Now all we have to do is create our views for each action. Once this is complete, you can run the application to see it in action.

Index.cshtml:

@using IceCreamYouScreamCorp.Web.Mvc
@model IEnumerable<IceCreamYouScreamCorp.Domain.Product>

@{
    ViewBag.Title = "Index";
}

<h2>Index</h2>

<p>
    @Html.ActionLink((ProductsController c) => c.CreateOrUpdate(0),"Create New")
</p>
<table>
    <tr>
        <th>
            Name
        </th>
        <th></th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.Name)
        </td>
        <td>
            @Html.ActionLink("Edit", "CreateOrUpdate", new { id=item.Id })
        </td>
        <td>
        @using (Html.BeginForm("Delete", "Products")) {
            @Html.Hidden("id", item.Id)
            <input type="submit" value="Delete" />
            @Html.AntiForgeryToken()
        }
        </td>
    </tr>
}
</table>

CreateOrUpdate.cshtml:

@model IceCreamYouScreamCorp.Domain.Product

@using (Html.BeginForm()) {
@Html.ValidationSummary(true)
<fieldset>
        <legend>Product</legend>

        <div class="editor-label">
            @Html.LabelFor(model => model.Name)
        </div>
        <div class="editor-field">
            @Html.EditorFor(model => model.Name)
            @Html.ValidationMessageFor(model => model.Name)
        </div>

        <p>
            <input type="submit" value="Save" />
        </p>
    </fieldset>

    @Html.AntiForgeryToken()
}

<div>
    @Html.ActionLink("Back to List", "Index")
</div>

Done!

Start the web project go to /Products to marvel at your creation.

We’ve achieved the basics of a CRUD operation, without touching on TDD or some other best practices, but this should get you going very quickly on using Sharp Architecture in your project.

Notes¶

These are general notes on updating, for specfic notes on updating check the instructions for the version you are updating to below.

In Visual Studio, open the Package Manager Console, and run:

Update-Package -Safe

Will only update packages where Major and Minor versions match what you have installed, which should work for patch updates (i.e. from 2.0.0 to 2.0.4) but will not update minor or major releases.

If any of the assemblies that have been updated are strongly named (most are unfortunatley), you would need to add assembly binding redirects to your applications config files (including the test projects). Luckily this can be done easily with nuget, in the Package Manager Console select run:

foreach ($proj in get-project -all) {Add-BindingRedirect -ProjectName $proj.Name}

2.0 to 2.1¶

You can pick and choose which of those packages you want updates, if you just want to update NHibernate, then just run the command with SharpArhc.NHibernate

Update-Package SharpArch.Web.Mvc.Castle
Update-Package SharpArch.NHibernate
Update-Package SharpArch.Testing.NUnit
Update-Package SharpArch.Domain

If you get problems with Iesi.Collections version mismatch, this is because versions of NHibernate < 3.3.1 didn’t specify the highest version of Iesi.Collections, causing problems now that there is a major version change released. To fix this, add allowedVersions=(,4.0) as an attirbute to the Iesi.Collections element to any packages.config file that has it.

Asking Questions¶

Join the google group and ask questions there or post your questions to stackoverflow with the tag ‘sharp-architecture’ and any other tags for projects your question might be related to (e.g. fluent-nhibernate, nhibernate, castle-windsor)

Related Projects¶

• Sharp Architecture Contrib
• Sharp Architecture Cookbook
• Castle Windsor
• NHibernate
• FluentNHibernate

Blog posts¶

• Enhanced Query Objects With S#arp Architecture

Multimedia¶

• Introduction to S#arp Architecture
• Another look at Sharp Architecture: Validation, Design Decisions and Automapping

Must reads¶

• Domain Driven Design Quickly free pdf
• Domain Driven Design
• Clean code
• Enterprise Integration Patterns
• Refactoring
• Test Driven Development
• Continuos Delivery
• And many more...

Recommended tools and libraries¶

• Deployment and configuration management

  • OpsCode Chef
  • Puppet
  • dropkick
  • Octopus Deploy
  • Rounhouse DB Migrations

• Profilers and productivity

  • Resharper
  • Ants Performance Profiler
  • Ants Memory Profiler
  • NHibernate Profiler

Contributing¶

• Contribution guidlines on S#arp Architecture github