5

I'm going through the (fantastic) book Head First Design Patterns and need some clarification on the observer pattern. The following little bit of code simulates a device (CurrentConditionDisplay) that listens for updates on weather patterns.

interfaces:

public interface ISubject { void RegisterObserver(IObserver obs); void RemoveObserver(IObserver obs); void NotifyObservers(); } public interface IDisplay { string Display(); } public interface IObserver { void Update(float temperature, float humidity, float pressure); }

Observer

public class CurrentConditionDisplay : IObserver, IDisplay { private float temperature; private float humidity; private float pressure; private ISubject weatherData; public CurrentConditionDisplay(ISubject weatherData) { this.weatherData = weatherData; this.weatherData.RegisterObserver(this); } public string Display() { StringBuilder sb = new StringBuilder(); sb.AppendLine("Welcome to Current Condition Display..."); sb.AppendLine(this.temperature.ToString()); sb.AppendLine(this.humidity.ToString()); sb.AppendLine(this.pressure.ToString()); return sb.ToString(); } public void Update(float temperature, float humidity, float pressure) { this.temperature = temperature; this.humidity = humidity; this.pressure = pressure; } }

Subject

public class WeatherData : ISubject { private List<IObserver> observersList; private float temperature; private float humidity; private float pressure; public WeatherData() { observersList = new List<IObserver>(); } public void RegisterObserver(IObserver obs) { observersList.Add(obs); } public void RemoveObserver(IObserver obs) { int index = observersList.IndexOf(obs); if (index >= 0) { observersList.RemoveAt(index); } } public void MeasurementsChanged() { Console.WriteLine("There is new data available..."); NotifyObservers(); } public void NotifyObservers() { foreach (IObserver observer in observersList) { observer.Update(temperature, humidity, pressure); } } public void SetMeasurements(float temperature, float humidity, float pressure) { this.temperature = temperature; this.humidity = humidity; this.pressure = pressure; MeasurementsChanged(); } }

To use these classes in my Program.cs I'm creating once instnce of WeatherData and passing that object as parameter to the constructor of CurrentConditionDisplay. A problem that I see with this current setup is that IObserver has one method Update which takes temperature, humidity, pressure as parameters. I see no guarantee that the Subject (WeatherData) has to have these fields in the first place. Should I add another interface or abstract base class to ensure that when SetMeasurements is called, all the fields being updated in that method are actually in the Observer?

Improve this question
10
  • 7
    FYI, C# has a built-in implementation of the observer pattern. See Events Commented Dec 12, 2013 at 14:02
  • What do you mean by 'ensure that all the fields being updated in that method are actually in the Observer'? Have read this several times and can't understand your problem Commented Dec 12, 2013 at 14:02
  • 2
    @JohnSaunders that's a book about design patterns. Goal is to understand observer idea, not to learn C# features) Commented Dec 12, 2013 at 14:03
  • @lazyberezovsky I meant that there's nothing making WeatherData have temperature, humidity, pressure as private fields. The Observer and Subject have no common interface (to share those fields that are udpated). Commented Dec 12, 2013 at 14:05
  • @wootscootinboogie I can't understand you again - temperature, humidity and pressure are private fields of weather data. Why you are saying that nothing making them as private fields? Commented Dec 12, 2013 at 14:06

4 Answers 4

Reset to default
2

I feel the same thing you do... having a rather generic sounding IObserver interface have a specific method signature that really only applies when observing WeatherData feels icky!

I'd much rather have something like this:

public interface IObserver<T> { void Update(T updatedData); }

With an observer that would look something like this (snipped some extra code here):

public class CurrentConditionDisplay : IObserver<WeatherUpdate>, IDisplay { public CurrentConditionDisplay(ISubject<WeatherUpdate> weatherData) { this.weatherData = weatherData; this.weatherData.RegisterObserver(this); } public void Update(WeatherUpdate update) { this.temperature = update.Temperature; this.humidity = update.Humidity; this.pressure = update.Pressure; } }

And just to make myself clear, my generic T for IObserver<T> would be an object that encapsulates a weather update:

public WeatherUpdate { public float Temperature; public float Humidity; public float Pressure; }

And ISubject would have to be changed to include the generic parameter as well:

public interface ISubject<T> { void RegisterObserver(IObserver<T> obs); void RemoveObserver(IObserver<T> obs); void NotifyObservers(); }
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

I think that is a good idea as well. If there were several different types of updates per device this would easily allow for CurrentDisplayUpdate or StatsDisplayUpdate or what have you.
1

If you wanted to enforce this, what you could do is define the properties for temp, humidity and pressure in your ISubject interface (see http://msdn.microsoft.com/en-us/library/64syzecx.aspx).

Then adjust the Update method in your IObserver interface (and the class that implements it) -- you can remove the parameters. Change the CurrentConditionDisplay class' Update method to look for the temp, humidity, pressure values from the properties of the object that implements ISubject.

Improve this answer

Comments

1

No, IObserver doesn't to have fields for temperature, humidity and pressure.

When it comes to interfaces its important to remember that interfaces are more closely tied to the needs of their clients (i.e. the callers, in your case the WeatherData class) rather than their implementations.

What I mean by this is that you should look at the interface from the perspective of the needs of WeatherData class first - this class uses the IObserver interface to notify others of changes to temperature, humidity and pressure and nothing more - it doesn't need to get the temperature, humidity and pressure from the observers (what would it do with this information?).

In fact some implementations of IObserver might not even persist this information - for example some sort of logging observer might log these changes and then completely discard this information. In this case adding these properties to the interface would force the observer into implement members that nether the observer nor the implementation actually needs!

When defining interfaces always think in terms of the methods and properties that the caller needs to use - everything else is implementation detail of the class that implements the interface.

Improve this answer

3 Comments

thanks :). So as a design choice would you agree or disagree with a new interface or abstract class that the observer and subject both implement that has the properties/fields to be updated?
@wootscootinboogie Good question, but figuring out when classes should inherit from each other is a different (more complicated) subject. In this case I'd say no, they don't need a common base class or interface (in general you shouldn't add base types just because they have the same members). See the Liskov Substitution Principle
intuitively I would've guessed that they would need a common abstraction expressly because they DID have common members. That little factoid is going to save me some headache.
0

Your right, with the current implementation there is no guarantee that the observer has the temperature, humidity and pressure properties. It doesn't matter as what is guaranteed is that you will receive this information with the update method is called.

ADDITIONAL READING

For clarity, consider taking a look at the real-world example:

DoFactory.com: Observer Pattern

Another great resource:

PluralSight.com: Design Patterns Library

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.