As I learn more and more from Domain Driven Design, my classes for DDD projects (those that are complex enough to need more than simple CRUD), are shifting from what are referred to as “anemic domain models” and more like “rich domain models”.

The term “anemic domain model” (which I still have an aversion to…the term, that is) refers to a class that doesn’t really do much at all. It has a bunch of properties and maybe some methods. To use them you instantiate or retrieve the object and then populate the properties at will. When working in DDD, the focus is on behaviors, not properties. So you would have methods to control what happens to  your objects and in doing so, constrain the properties so that they are not exposed to be set or modified “willy nilly”.

Here is an extremely simple pair of classes that are designed using some of the techniques I’m learning from DDD:

  public class AThingAsEntity
  {
    private AThingAsEntity(){}  //the private constructor

    public AThingAsEntity(string description, int anInt, string aString)
    {
      Description = description;
      SomeOtherThing = new SomeOtherThing(anInt, aString);
    }

    public int Id { get; private set; }
    public string Description { get; private set; }
    public SomeOtherThing SomeOtherThing { get; set; }

    public void TheOtherThingMustChange(int anInt, string aString)
    {
      SomeOtherThing = new SomeOtherThing(anInt, aString);
    }
  }

  public class SomeOtherThing:ValueObject<SomeOtherThing>
  {
    private int anInt;
    private string aString;

    private SomeOtherThing(){} //the private constructor 

   //this value object’s constructor is internal to prevent random instantiation
   internal SomeOtherThing(int anInt, string aString) 
    {
      AValue = anInt;
      AnotherValue = aString;
    }

    public int AValue { get; private set; }
    public string AnotherValue { get; private set; }
  }

I’m constraining the class so that anyone who instantiates it is required to pass in some values. And those values all have private setters. There’ s no way to write code like:

var thing=new AThingAsEntity();
thing.Description="oh i'll just put whatever I want in here. heh heh heh. Domain rules be damned";

That’s the way I want to write this class to represent my domain.

In the past week or so, I’ve been asked three separate times (by three different developers) if it’s possible to use this pattern of private setters with EF. The answer is “yes”. Here, let the Doctor confirm that:

And in case you’re curious, I’m doing this with EF5.

Entity Framework requires a parameterless constructor in order to materialize objects returned from queries (or loading). I  have made this concession in my class but notice that it is a private constructor. So I’m still protecting my class. Nobody can access it. But EF is still able to populate this class when I execute queries. And no, I’m not doing some magic to tell EF to use my public constructor. It really uses the private constructor.

I’ll use an integration test to demonstrate.

Note that my test is using an initializer called SeedMyThings to always drop and recreate the database and shove in this seed data:

      new AThingAsEntity("This is MY thing", 42, "That is the meaning of life")

My test sets that initializer so I can perform the test I’m interested which requires some seed data.

[TestClass]
  public class Tests
  {
    public Tests()
    {
      Database.SetInitializer(new SeedMyThings());
    }
    [TestMethod]
    public void EfCanPopulateObjectWithPrivateCtorAndSetters()
    {
      using (var context=new ThingieContext() )
      {
        var thing = context.Things.FirstOrDefault();
        Assert.IsInstanceOfType(thing,typeof(AThingAsEntity));
        Assert.AreNotEqual(0, thing.Id);
        Assert.IsFalse(string.IsNullOrEmpty(thing.Description));
        Assert.IsFalse(string.IsNullOrEmpty(thing.SomeOtherThing.AnotherValue));
      }
    }
  }

I know…all those Asserts…bad tester.  So shoot me. 😉

Anyhooooo…. the test passes. Even with my private ctor and private setters, EF is able to materialize the object and even it’s SomeOtherThing property which is a value object. (which also has a private ctor and private setters). Internally EF is reading the metadata of the model and using reflection to set the values of the properties.

I also want to point out that I had been using a protected constructor. In the past, I am sure I tried private and it didn’t work. (Maybe an earlier version of EF?) But Steve Smith asked me “if setters work as private, why not constructor?” So I tried it and voila, it worked too.

And now, for my first EVER public Git repository. You can find my little sample solution at https://github.com/julielerman/EF_and_Private_CTORs_n_Setters. 🙂

I occasionally get emails asking what order would be best for watching my current Entity Framework courses.

Up through EF4, I recommended watching them in order of the date published, but with the addition of my EF5 course, that has changed.

The most important thing to keep in mind is that most of the older courses are still totally relevant. They cover critical features  of Entity Framework that have not changed (or have *barely* changed) since I published the original course.

So here is my recommendation with some relevant comments since not everyone is starting from the same place:

(BTW if you don’t have a Pluralsight subscription …but they are only $29/month for access so all 650+ courses!! …go to my contact form and shoot me an email. I’ll hook you up with a free trial so you can watch my courses (and the others, too!). But be warned, once you are lured into the goodness of Pluralsight, you’ll want to become a full-fledged subscriber! 🙂 )

Getting Started with Entity Framework 5      (Mar 2013)       4:23 (this is the longest course, the rest are around 2 hrs each)

This is the newest course. This is relevant if you are just starting with EF5 or moving from a previous version. It is an intro course which touches on a lot of topics and digs further into the most important getting started topics. Most importantly, I always point to the relevant course/module where you can dig even further when you’re ready. The course starts with an overview of what EF is and why you may want to use it. It also provides a look at what has changed since earlier version. The course then has individual modules about database first, model first & code first modeling. Since Database and Model first both use the designer, I spend more time in the database first module talking about the new designer features. For the rest of the designer features, you should look at the EF & Data Models course and Designer Supported EDM Customization, though keep in mind that both of those were done with VS2010.

The next module focuses on using the DbContext to interact with your model …understand the basic concept of querying and updating, how EF change tracks etc. It then points to the DbContext course & Querying course for more details.

The last module talks about how to fit EF into your apps …some basic architecture, some tricks and a quick look at EF in various applications (WPF, MVC and a short discussion of mobile apps). There are some more in-depth end-to-end courses that happen to use EF for the data layer in the Pluralsight library as well.

Entity Framework 4.0 By Example (Aug 2010)

This is a compilation of a series of short videos. The last three are still useful. The one on T4 templates with the designer-based model is useful if you are doing database first or model first but keep in mind that with VS2012, the default template used with the designer is now a template that generates simpler (POCO )classes and a DbContext rather than an ObjectContext. You can learn some more data-binding tricks in the 4th model and get a better understanding of POCOs in the final module.

Entity Framework 4.1 – Code First  (Jun 2011)

This will fill in many blanks from the Code First module of the EF5 course. I spend a lot of time talking about various configuration & modeling techniques and they have not changed.

Entity Framework Code First Migrations   (Mar 2012)

I touch on migrations in the EF5 course but this goes much more in-depth. Again, not much has changed since this course. The one notable change (which I pointed out in the EF5 course) is that with EF5, when you are using Automatic Migrations, the seed method gets hit every time database initialization happens, not *only* when something is migrated.

Entity Framework and Data Models   (Nov 2010)

This focuses on Database First and Model First. It uses the designer in VS2010, so some of the newer features added in VS2012 you can see in the Getting STarted with EF5 course but then the rest you can see here.

Designer Supported EDM Customization   (Jan 2011)

If you are using the designer, this is still a very important and relevant course.

Entity Framework 4.1 – DbContext  (Sep 2011)

The DbContext has not changed too dramatically since EF4.1 was released. You can fill in some blanks from the EF5 course with this one.

Querying the Entity Framework     (Feb 2011)

This courses uses the ObjectContext for querying so some things have definitely changed. If you watch it *after* the EF5 & DbContext courses, then you can pick up some querying logic/syntax tricks like grouping, navigation properties and nested queries here. I don’t cover those anywhere else. by the time you get to this course, you should be able to easily see what’s new and useful and skip the rest.

Data Layer Validation with EF 4.1+   (Feb 2012)

This is an important feature of the DbContext and has not changed with the release of EF5. You don’t want to miss this one!

Entity Framework in the Enterprise    (Sep 2012)

This is not a “features” course but one about using EF in enterprise architectures. I did this using Code First and VS2010. But given that it is about architecture & testing, not features & syntax, it does not lose its relevancy. You may even want to watch (or poke around) this course earlier and then watch it again after you’ve gone through some of the more advanced courses so that things like syntax etc will make more sense.

COMING UP!

What’s New in EF6: I will be creating an EF6 course that will focus on what’s new. EF6 mostly brings new advanced features. Hardly any of what’s already there will change. One notable change however is that Code First will support stored procedure mapping. In the EF5 course, I do point out some things about EF6 ..most notably in the first module.

Domain Driven Design: I’ll be co-authoring this course with Steve Smith (who has authored many of the Design Patterns courses in the Pluralsight library). You’ll notice from the EF in the Enterprise course that I’ve been getting more and more involved with DDD. So while this course will focus on DDD, not on EF, we will certainly be using EF in many examples where data access comes into play.