Domain model question on inheritence

Question

I need some advice on modeling the following movies domain. I have a person entity. This person can be an Actor, Director, Producer and Writer and will often be all. I don't want to dup data in each entity so feel it best to create an abstract base class called Person that each of the Director, Actor and Writer classes inherit from. This has started to smell a when I look at the following test:

[Test] public void Can_Do_It()
{
   var actor = new Actor("Clint Eastwood");  
   var director = //?? Can new it up as he already exists as actor  }

Is it more preferable to have a Person Class and then have Classes like Writer that take in an instance of person i.e.

public class Writer(Person person, string attribute1, string attrribute2) {...}

Answer 1

You should look at a composition rather than inheritance based model for this. Fairly standard design pattern for this sort of thing - in fact, I suspect (don't have a copy to hand) that it's in the Gang of Four design patterns book if you want more information.

Answer 2

A common solution would be to introduce the concept of 'role' (quite fitting in this case). A person can be an Actor in 0+ movies, and/or fill a Director Role.

That also allows you to add attributes to the role, like character-name, dates etc

---

Edit:

The Role class would have 2-way associations with both Person and Movie.

class Role
{
     public Person Contributor { ... } 
     public Movie  Feature { ... }
     public RoleType Activity { ... }
}  

class Person
{
    public List<Role> Contributions { ... }
}        

class Movie
{
    public List<Role> Contributors { ... }
    ...
}

Answer 3

You could have a concrete class Person with all the common details of a person, and then the person class would also have a collection/list of roles. The roles would be Actor, Writer, etc. and they would have all the necessary extra attributes + behaviour.

Answer 4

If your "roles" are finite and can be defined up-front (as seems the case in your example), you could use a bitwise enum flag on the Person class.

class Person {
   [Flags]
   public enum EnumRole {
      None = 0,
      Actor,
      Director,
      Producer,
      Writer
   }

   public Person( EnumRole role ) {
      Role = role;
   }

   public EnumRole Role { get; set; }

   public bool CanDo( EnumRole role ) {
      return (Role & role) != EnumRole.None;
   }
}

Then create your person with the required roles:

Person p = new Person(Person.EnumRole.Actor | Person.EnumRole.Director);

... and check if they have a required role ...

bool canDoIt = p.CanDo(Person.EnumRole.Actor);