Question

I’m building a small timing application using the MVVM pattern, using entity framework for persistence. At this stage, my logic is pretty thin, as I only need to perform a few calculations and aggregations on related data. At the moment, I have implemented these by writing them in a partial class of the entity class.

For example:

// entity framework generated
partial class Lap {
  int Id { /* boilerplate */ }
  DateTime StartTime { /* etc */ }
  DateTime EndTime { /* etc */ }
}

// in my partial class (written by me)
partial class Lap {
  TimeSpan Duration {
    get { return EndTime - StartTime; }
  }
}

Is it bad practice to drop extra logic straight onto the entity-generated classes? Should I make another domain layer for this logic?

Answer 1

You are doing the very thing for which partial classes were designed; adding relevant logic to a code-generated class without bogging down the inheritance tree. Keep it up.

Addition:

From a page in the font of all tribal knowledge, Wikipedia (emphasis added):

The purpose of partial classes is to
allow a class’s definition to span
across multiple files. It is
especially useful for:

• Very large classes (where it is cumbersome to navigate with an editor
  through a single file)
• Separation of concerns, in a way similar to aspect-oriented programming
  but without using any extra tools. An
  example is shown below.
• Allowing multiple developers to work on a single class at the same
  time without the need for later
  merging files in source control.
• Allowing a separation between the class interface and the
  implementation-related definitions
  (Separate definitions of the public
  and private parts)
• Easing the writing of code generators, such as visual designers.
  This is perhaps the most useful
  reason. It is a challenge to develop
  code generators that can manage the
  generated code when it is placed in
  the human-written code:
  • Requires a lot of parsing of unnecessary code, just to find a
    place to insert the generated code.
    Altering the code is also a problem.
    Poorly written generators hold the
    potential risk of damaging the entire
    file.

Using partial classes, the code
generator processes a separate file,
and is thus alleviated from all the
above mentioned problems.