The Object-Oriented way to separate the model from its representation

Question

Suppose we have an object that represents the configuration of a piece of hardware. For the sake of argument, a temperature controller (TempController). It contains one property, the setpoint temperature. I need to save this configuration to a file for use in some other device. The file format (FormatA) is set in stone. I don't want the TempController object to know about the file format... it's just not relevant to that object. So I make another object, "FormatAExporter", that transforms the TempController into the desired output. A year later we make a new temperature controller, let's call it "AdvancedTempController", that not only has a setpoint but also has rate control, meaning one or two more properties. A new file format is also invented to store those properties... let's call it FormatB. Both file formats are capable of representing both devices ( assume AdvancedTempController has reasonable defaults if it lacks settings ). So here is the problem: Without using 'isa' or some…

Accepted Answer

What you can do is let the TempControllers be responsible for persisting itself using a generic archiver.

```
class TempController 
{
    private Temperature _setPoint;
    public Temperature SetPoint { get; set;}

public ImportFrom(Archive archive)
    {
        SetPoint = archive.Read("SetPoint");
    }
    public ExportTo(Archive archive)

{
        archive.Write("SetPoint", SetPoint);
    }
}

class AdvancedTempController
{
    private Temperature _setPoint;
    private Rate _rateControl;
    public Temperature SetPoint { get; set;}
    public Rate RateControl { get; set;}

public ImportFrom(Archive archive)
    {
        SetPoint = archive.Read("SetPoint");
        RateControl = archive.ReadWithDefault("RateControl", Rate.Zero);
    }

public ExportTo(Archive archive)
    {
        archive.Write("SetPoint", SetPoint);
        archive.Write("RateControl", RateControl);
    }
}
```

By keeping it this way, the controllers do not care how the actual values are stored but you are still keeping the internals of the object well encapsulated.

Now you can define an abstract Archive class that all archive classes can implement.

```
abstract class Archive
{
    public abstract object Read(string key);
    public abstract object ReadWithDefault(string key, object defaultValue);
    public abstract void Write(string key);
}
```

FormatA archiver can do it one way, and FormatB archive can do it another.

```
class FormatAArchive : Archive
{
    public object Read(string key)
    {
        // read stuff 
    }

public object ReadWithDefault(string key, object defaultValue)
    {
        // if store contains key, read stuff
        // else return default value
    }

public void Write(string key)
    {
        // write stuff
    }
}

class FormatBArchive : Archive
{
    public object Read(string key)
    {
        // read stuff
    }

public object ReadWithDefault(string key, object defaultValue)
    {
        // if store contains key, read stuff
        // else return default value
    }

public void Write(string key)
    {
        // write stuff
    }
}
```

You can add in another Controller type and pass it whatever formatter. You can also create another formatter and pass it to whichever controller.

The Object-Oriented way to separate the model from its representation

Solution

Problem