I have been trying to wrap my head around the role of the DTO in DDD. My reading of Fowler and Evans seems to indicate that you ought to have your domain objects themselves mapping into your database, rather than dedicated function-less DTOs. Relying on DTOs that are then handled by Services seems to lead to what Fowler calls The Anemic Domain Anti-Pattern: http://martinfowler.com/bliki/AnemicDomainModel.html

However, I have a tough time writing Entity classes that operate in that manner that don’t end up rather painful to change and extend.

Since you recommend the practice of using DTOs, do you have any thoughts on the subject?

Thank you for the question Scott, of course I have thoughts on this

Disclaimer: This sort of architecture is not applicable to many systems, use the right patterns and tools for the job!

I agree that an anemic domain model is bad, if there is no behavior then what’s the point right? Let’s make sure I am on the same page here:

DTO: To me, a DTO moves data between ‘tiers’. They are the packaged data ready for transport. A WCF data contract is a perfect example of a DTO, I also see a JSON object as a DTO.

Read model: This would be a different model than your real Domain model.  A Read model is very lightweight, ‘thin’ and anemic.  Its purpose is to serve aggregated data to a specific screen or message. A DTO, to me, can be a read model, as too could be a View Model.

The domain model is rich and full of behavior. This model is most valuable when performing complex business rules during the saving and updating of data within a given transaction. It can also be used to read data too, but consider this contrived example:

Let’s say that we want to display the top 10 products. The products include the Manufacturer Name, Product Name, Vendor Name,  Product Price,  Customer Ranking. Being that we are good modelers we come up with something like the following entities: Vendor, Manufacturer, Product,  &  ProductRanking (maybe localization & currency support tables too).

If I use my domain model to get this data, I am going to end up retrieving quite a bit more data than I actually need, which could degrade performance. Not to mention having to deal with dot notation everywhere foo.Name =a.b.c.d. 

We only need 5 fields, and they are immutable for this operation.

My preference is to materialize the read model (DTO, View Model) by projecting from the Domain Model, or by using a Stored Procedure for more complicated recursive, spatial or temporal queries.

Splitting the models allows the reads & writes to fluctuate independently, so which leads to higher maintainability. These models can also run on different tiers/nodes to increase scalability (read/cache tier, write tier).

At some point, whether off a view or an inbound DTO, there will be mapping back into the domain model. This ‘friction’ or ‘impedance’ is pretty easy to manage using an assembler/translator, or a tool like AutoMapper.

Greg Young & Udi Dahan take this concept further and apply a programming principle called Command-Query Separation with distributed programming and SOA. I think it is very good stuff.

Here are some posts that are all somewhat related:
http://jonathan-oliver.blogspot.com/2009/03/dddd-and-cqs-getting-started.html
http://www.udidahan.com/2008/08/11/command-query-separation-and-soa/
http://codebetter.com/blogs/gregyoung/archive/2009/08/13/command-query-separation.aspx
http://elegantcode.com/2008/04/27/dtos-or-serialized-domain-entities/
http://elegantcode.com/2008/04/30/altnet-seattle-takeawayddddresources/

By default an text box is generated for DateTime fields. What I wanted to do was hook this up to the excellent Datepicker widget from jQuery UI. Here’s how I achieved this:

1. Add the following 3 references to the Master Page:

   <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
   <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js"></script>
   <link href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/themes/overcast/jquery-ui.css" type="text/css" rel="Stylesheet" class="ui-theme" />

   I am referencing jQUery and jQUery UI from the Google CDN (great for getting started quickly as well as for production scenarios). I am also linking to one of the default themes which goes nicely with the default MVC stylesheet.

2. Add the following Javascript to the Master Page:

   <script type="text/javascript">
       $(function () {
           $(".date-edit-box").datepicker();
       });
   </script>

   Here I am simply looking for a specific class and attaching a Datepicker widget to it. I am aware that this is not the most efficient approach as the code might run unnecessarily but it’s perfect for a demo.

3. Ensure that the correct class is rendered by the Template. Apparently you can currently only override the default templates for individual Controllers. Therefore create a Views/{ControllerName}/EditorTemplates folder and within it create a file called DateTime.ascx which should contain:

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>

<%= Html.TextBox("", ViewData.TemplateInfo.FormattedModelValue, new { @class = "date-edit-box" }) %>

4. You’ll probably want to use the DIsplayFormatAttribute on the DateTime fields in the View Model to ensure that the time is not also output (don’t forget to set the ApplyFormatInEditMode property to true if you do this).

That’s it. You should now see Datepickers for the appropriate fields that were rendered using the Html.EditorForModel() extension method.

• Retrieve data by aggregate roots, have a repository for each root. The root queries should return the entire aggregate. If you are going to defer loading to a part of the root graph, be explicit. Instead of lazy loading Foo.Bars, I like to say Foo.LoadBars() <- yes seriously
• Learn how to identify the right aggregate
• Respect your aggregate root boundaries. Aggregates cannot call into other aggregates children! You shouldn’t be adding a product from the order, really, this is bad: LineItem.Product.Calatalog.Add(new Product). The order AR just crossed into the Catalog AR. Its not the job of the Order to add products to the catalog
• Do not try an overuse an aggregate, its ok to create a new one. Less is more does not apply. Fulfilling an order is different than placing one, and your data access may need to reflect that
• Use a ‘Read Model’. The most common approach here is using DTO or ViewModel, and projecting straight into it from the object model query or database
• For complex queries that perform aggregations and calculations, consider using a store procedure. They really have their place, even with the best ORM’s (then project into Read Model)
• Avoid putting query logic in mappings (Assembler’s, Translators, AutoMapper)
• Use a tracing tool. I like the SQL trace profiler, but if you are not as comfortable with sql, there is a some good profilers around, like NHProf for nHiberante & soon EFProf for the Entity Framework
• Know the SQL that is going to your database. Have your tests emit the generated sql out to the console. Live it, learn it, love it. You should know your ORM tendencies, especially if you are using a linq provider
• Batch requests to your services and database, especially if you are in a web or distributed environment

I’ve seen this one all too many times:

Business guy: The order checkout screen is running slow in production

Dev: It shouldn’t be, it runs great on my machine

Business guy: Well, it is. It takes 10-15 seconds to load order 123

Dev: Let me check, ya hmm, it is slow. I’ll look into it

The developer proceeds to crack open the source where he finds some LOD nightmare data binding mess in the view, or the mapping to the presentation model: “Customer.Order-> LineItem.Product.Catalog.Vendor.Name”

Because someone wanted to display the Vendor name on the line detail, they just hopped over the graph and loaded the catalog, and then vendor. So here comes the entire catalog! (of course its N + 1)

Why did they do that? Because it is EASY! (and because your boss wanted it yesterday)

The team never knows about it until it’s too late. Yep, it runs fast locally, because we developers only have a small catalog on our machine, I mean “we don’t want all that data on our box”.

Now I know there are many folks out there saying “Well that’s just stupid, I would never do that”. Maybe you wouldn’t, but that guy sitting next to you, he will. I tell you, we all do it, again and again.

The result over time is an interconnected web of queries that can bring a system to a crawl.

See my follow up post for some tips I use when designing a data access layer with an ORM

One of the things that I had stopped doing was keeping an eye on various OSS projects to see what was on the horizon. Yesterday I (finally!) started to experiment with NHibernate 3.0. The first thing that caught my eye was QueryOver. As Fabio explained there are a lot of different ways of executing queries in NH. Certainly in the pre-LINQ days ICriteria was the predominantly recommended option because it has elements of type safety to it and its fluent-ish API broke everything down into small pieces and avoided string concatenation hell.

QueryOver is fluent a layer on top of ICriteria. It looks very LINQesque but it’s a very different animal, not least of all because there are some concepts in ICriteria that do not have a LINQ equivalent (caching etc.). In the short to medium term I suspect that it will become my de facto approach for NHibernate queries (I’ve used NHibernate LINQ and it’s great for simple queries but I’ve experienced significant issues with more complicated ones).

What I haven’t figured out yet is how, if at all, this will affect my data access testing strategy. Historically I’ve favored smoke tests that have really been doing little more than verifying that a given ICriteria query was semantically valid. Typically I only resorted to actually worrying about the results in specific cases (mainly due to the burden of maintaining test data for each possible scenario). Then again this sounds like a topic for another post doesn’t it…

I found that this can be done using the TFS Power Tools via the command line.

tfpt.exe destroywi /server:http://ServerName:8080 /workitemid:123

You will get a warning:

This action is not recoverable. Are you sure you want to destroy work item(s)123? (Y/N)

Work item is gone.

Jason Dean and the ALPN group is leading a series of workshops on Agile practices.  They are designed to proceed from entry level discussions to more advanced.  Look for more information on further workshops.

For more information, checkout:

The website: www.agileboise.org

The ALPN Boise Google group: http://groups.google.com/group/apln-boise?hl=en&pli=1

Since the application was previously built on version 3.5, IIS was configured to run as Asp.Net 2.0. Well it turns out IIS runs under the new framework version 4.0. (not like 3.0, or 3.5 when the Application Pool runs as 2.0)

Kind of one those "I should have figured that out much quicker moments"… A simple change to the app pool to target 4.0, and were on our way.

I’m writing a very basic WebPart to get started with SharePoint – this web part will display a list of links to other applications that the user is authorized to use.  The source of this data (names, URLs, etc.) comes from an external-to-SharePoint system, accessed through another C# assembly.  Once the web part gets the data there is some more processing to be done – we need to do more than just blindly display a list of URLs.  Rather than get into details I’m just going to do some handwaving here and say that “if you have access to X, then {stuff happens}, or if you have access to Y then {other stuff happens}.”  You know, business logic, stuff that is good to test.

the first thing I need to do is get business logic out of the WebPart and into something that I can write without having to reset AppPools over and over, not to mention have some unit tests to verify I’m going in the right direction.  So, I created a standard application service class which has a dependency on the external authorization system, via constructor injection. 

public class AuthorizedAppsService : IAuthorizedAppsService
{
  private readonly ExternalAuthorizeService authService;

  public AuthorizedAppsService(
    ExternalAuthorizeService authService)
  {
    this.authService = authService;
  }

  public AuthorizedApplications GetAuthorizedApplications(
                                  string userName)
  {
    var allApps = authService.AuthorizedApplications(userName);
    // business logic stuff happens here
    return thoseResultsWeJustFiguredOut;
  }
}

Next, I created a StructureMap Registry class to scan my assemblies, as well as adding in the details of how to create this external authorize service, using the typical method:

public class MyRegistry : Registry
{
  public MyRegistry()
  {
    Scan(scanner => {
      scanner.TheCallingAssembly();
      scanner.AssemblyContainingType(typeof(MyRegistry));
      scanner.WithDefaultConventions();
      });

    ForRequestedType<ExternalAuthorizeService>()
      .AsSingletons()
      .TheDefault.Is.ConstructedBy(c => Provider.GetService());

    // other dependency configuration...
  }
  public static void InitializeForSharepoint()
  {
    ObjectFactory.Initialize(init => init.AddRegistry<MyRegistry>());
    ObjectFactory.AssertConfigurationIsValid();
  }
}

And then, what remains is to have SharePoint call my StructureMap initialization when my SharePoint application starts up.  In an MVC or WebForms app, I’d just add code to the appropriate place in Global.asax.cs, but in SharePointLand, this is looked down on.  Instead, the preferred mechanism seems to be to use an HttpModule and a FeatureReceiver to plug the Module into the app’s web.config.

public class MyStartupModule : IHttpModule
{
  public void Init(HttpApplication context)
  {
        ConfigureOtherStuff();
        MyRegistry.InitializeForSharepoint();
  }
  public void Dispose() { }
}

And then the FeatureReceiver to alter the app’s Web.Config looks something like this (note I borrowed most of this code from another sample SharePoint project:

//
// this is borrowing heavily from http://www.codeplex.com/SPAXO
// 
public class StartupFeatureReceiver : SPFeatureReceiver
{
  public override void FeatureActivated(
        SPFeatureReceiverProperties properties)
  {
    var webApp = properties.Feature.Parent as SPWebApplication;
    AddWebConfigEntry(webApp);
    UpdateApp(webApp);
  }

  public override void FeatureDeactivating(
        SPFeatureReceiverProperties properties)
  {
    var webApp = properties.Feature.Parent as SPWebApplication;
    RemoveWebConfigEntry(webApp);
    UpdateApp(webApp);
  }

  private static void AddWebConfigEntry(SPWebApplication webApp)
  {
    SPWebConfigModification mod = GetModification();
    var existingModifications =
             new List<SPWebConfigModification>(
                      webApp.WebConfigModifications);
    if (existingModifications.FindIndex(
                    value =>
                        value.Name == mod.Name &&
                        value.Value == mod.Value &&
                        value.Owner == mod.Owner) == -1)
    {
      // If the modifcation does not already exist 
      // add the entry to the config
      webApp.WebConfigModifications.Add(mod);
    }
  }

  private static void RemoveWebConfigEntry(
            SPWebApplication webApp)
  {
    SPWebConfigModification mod = GetModification();
    webApp.WebConfigModifications.Remove(mod);
  }

  private static SPWebConfigModification GetModification()
  {
    string asmName = typeof(StartupModule).AssemblyQualifiedName;
    string typeName = typeof(StartupModule).FullName;

    return new SPWebConfigModification
      {
        Path = "configuration/system.web/httpModules",
        Name = String.Format(CultureInfo.InvariantCulture,
                "add[@name='{0}'][@type='{1}']",
                typeName, asmName),
        Sequence = 0,
        Owner = asmName,
        Type = SPWebConfigModification.
                    SPWebConfigModificationType.EnsureChildNode,
        Value = String.Format(CultureInfo.InvariantCulture,
                  "<add name='{0}' type='{1}' />",
                  typeName, asmName)
      };
  }

  private static void UpdateApp(SPWebApplication webApp)
  {
    // Update the Web App and apply the changes 
    // to all servers in the farm
    webApp.Update();
    webApp.Farm.Services
        .GetValue<SPWebService>()
        .ApplyWebConfigModifications();
  }
}

Additionally, we ended up on the one mystery topic that has always eaten away at me. That mystery for me is simple:

Why does one person or team pursue excellence relentlessly while another hits the door at 5:01 and doesn’t think about software development until tomorrow morning?

I got into the same discussion with Ted Neward at the recent P&P Summit while playing pool. Heck, it was almost an argument. I said something stupid that night. I said, “It’s all about incentives.”

Wrong.

One Theory: Incentives

I have had the opinion for years that there must be some motivator, some technique, or some dynamic that will affect people positively to simply care. This is the whole idea behind coaching, after all. A well-versed and motivating individual comes into a team and works with them to get better results. This happens every day.

If this will really work, it necessarily means that people are motivated by incentive. What I mean by that conditions like salary, a great leader, wonderful co-workers, free pizza and soda (or something) will inherently motivate someone to care about excellence.

Certainly no one can deny that incentives like these contribute to an enjoyable workplace. Heck, I love visiting the Microsoft campus and downing those free V-8s. All of them combined though, probably cannot cause someone to ponder, read, and learn. Incentives cannot move someone to try a new coding technique just because it might be interesting.

The Irritatingly Simpler Theory that is Likely True

There is just something about unique about people who can’t stop trying to improve. It isn’t the great boss or the great office space that causes me to think about the finer points of TDD in the shower. It’s just because I can’t NOT do it.

Both my mom and Ted Neward tried to get me to see that incentives will get you behavior and results (sometimes the ones you actually want), but can’t create passion. That is something that is simply innately there or not there.

This isn’t to say that there is no value in the person who wants to do their bid and get fair pay for a fair day. That’s not what I’m talking about. I am talking about the fact that most genius is recognized by relentless pursuit, the kind we can’t define.

The Good News

OK. Uncle, I get it. The great news is there are so many of us passionate geeks out there striving to improve. You wouldn’t likely be reading this if you weren’t one. Heck, I even geek to work with some!

What’s your theory? Are passionate professionals just the obsessive-compulsive ones?