I understand and agree with the Single Responsibility Principle. But have we gone too far the other way where an object doesn't do much except for carry around data and doesn't know what to do with its own data? Say you have a Person object that holds all of the data for a person - what do you do when you want to update that person in the data store? More times than not you will pass your Person object to another object that knows how to update the person.
Example:
IPersonUpdaterProvider provider = new PersonUpdaterProvider();
provider.UpdatePerson(person);
Whatever happened to the Person object knowing how to update itself? Internal to the person you may have your PersonUpdaterProvider that is read from a config file or use the provider given as a parameter etc..but the code accessing and needing to update the person only needs to call a version of Person.Update().
Example:
Person customer = new Person();
//...update some stuff
person.Update();
Person customer = new Person(customProvider);
//...update some stuff
person.Update();
The functionality is all the same and the flexibility is still there. Internally, the person doesn't know anymore than to call the UpdatePerson() method of the provider and passes itself. I think we're OK from a single responsibility perspective but we've also added in Tell, Don't ask and a dash of Encapsulation. In my example, the calling code doesn't need to know about how the person gets updated (unless they really have a need to know). The person knows what to do - so why can't we leave it to the person? This helps keep things clear when a developer is working with the person object. They can see an update method on the object and see what they need to use to get the person's data updated. No need to ask around to find out what provider/class is used to get a person updated in the data store.
I look at this and I can see that maybe we have the PersonUpdaterProvider created for each instance of a person when they could all use the same one. Mark the default provider inside the Person object with static and now only one default provider will get created and they can all use it. You can have an instance variable to store the custom provider so it can be used if needed without forcing all of the other person objects to use it too.
So it might look something like this.
namespace Eriks
{
public class Person
{
private static readonly IPersonUpdaterProvider _provder =
new DefaultPersonUpdaterProvider();
private IPersonUpdaterProvider _customProvider;
public Person()
{
}
public Person(IPersonUpdaterProvider customProvider)
{
_customProvider = customProvider;
}
public void Update()
{
if (_customProvider != null)
{
_customProvider.Update(this);
}
else
{
_provder.Update(this);
}
}
}
internal class DefaultPersonUpdaterProvider : IPersonUpdaterProvider
{
public void Update(Person person)
{
// update the data the default way...
}
}
public interface IPersonUpdaterProvider
{
void Update(Person person);
}
internal class CustomUpdaterProvider : IPersonUpdaterProvider
{
public void Update(Person person)
{
// update the dat in a custom way...
}
}
}
Example Usage:
namespace Eriks
{
public class PersonTest
{
public void DoSomething()
{
Person person = new Person();
person.Update();
Person person2 = new Person(new CustomUpdaterProvider());
person2.Update();
}
}
}
Giddy Up!