3

I'm having issues on how to seperate property values and their accessors. I have some electronic instruments encapsulated into classes. Some wrap a DLL which was provided by the manufacturer to handle communications.

A simple example:

public class Instrument
{
    private ManufacturerDLL.Instrument _instrument;

    public Instrument()
    {
        _instrument = new ManufacturerDLL.Instrument;
    }
    public float SomeSetting
    {
        get
        {
            return _instrument.SomeSetting;       
        }
        set
        {
            _instrument.SomeSetting = value;
        }
    }
}

Once connected, I can edit the properties with a propertygrid. I want to use serialization to not only save/restore the settings to a file, but also edit the settings with the device offline. With the implementation above, exceptions will throw if the device is not connected. I could add private fields as a middle man and if statements to check for connection status. But I have a lot of properties and hope there is a better way.

Is there an easy method to construct an 'abstract' version of an object? I basically want a clone but replace the original accessors logic with private fields. I know I can use GetMembers, but where to go from there?

Improve this question
3
  • Does Instrument implement any interfaces? In case it does, you could try to generate a proxy. Commented Nov 7, 2011 at 19:56
  • 1
    Steven, yes. The assembly from the manufacturer has interfaces which I actually use but didn't realize it was important info for this question. Why must it implement an interface? I'm not familar with the proxy pattern but at first glance looks like what I am talking about when I say 'abstract' version. Can I use reflection.emit to make the proxy in runtime or do I need to do it manually? Commented Nov 7, 2011 at 20:21
  • Well theoretically you can do it at runtime, but it is quite advanced stuff. I'll post an answer which might get you started. Commented Nov 7, 2011 at 21:07

2 Answers 2

Reset to default
1

You have several possibilities, so you'll have to decide based on your specific situation which seems most feasible.

Separate: As in Marc Gravell's answer, you could separate your model entirely from the manufacturer's and use an external parser which handles desired transactions by doing specific calls. I would only use this approach if you can't imagine an abstraction layer to work with on top of the original DLLs.

Decorator: Since you want to add behavior to a given library (check for connection), the first thing that comes to mind is using the decorator pattern. This basically comes down to what you were implying in the first place; wrapping the entire DLL and implement extra intermediate logic where necessary. Since you write the decorator manually, there are plenty of API changes you can do in order to suit it to your needs.

Proxy: Based on how varied this intermediate logic you want to implement is, you could consider using a proxy pattern. E.g. when all you want to do is expose the original properties, and add the same extra behavior for every property. When the Instrument classes of the manufacturer implement interfaces, you could generate a class which implements this interface at run time, and redirects the calls to the actual DLL of the manufacturer. This isn't easy, but there are a few libraries which can help you do just that. Castle DynamicProxy, or more low-level RunSharp. Only consider walking this path when you can reap the benefits of it. E.g. when you are supposed to wrap a big library, or a library which changes often over time.

When all you have to do is wrap 20 properties, I suggest you go for the decorator approach. When you have some spare time on your hands it might still be interesting to have some fun with run time code generation and attempting to generate a proxy.

I can give you an example of a run time generated proxy created by using RunSharp, just to give you a feel of whether it is something you would like to attempt. The CreateGenericInterfaceWrapper<T>() function wraps any interface with a 'less generic' interface, generating casts where needed.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks Steven. I reviewed my wrapper class and referenced my design pattern book. It is indeed a decorator. I plan on modifying the decorator to meet the requirements for the first crucial instruments. Hopefully by then I'll figure out if a dynamic proxy is worth the time. I have about 20 instruments to build, so I'm guessing the decorator will stick.
1

If that was me, I would separate the 2 things, specifically a: my representation of the data (used for serialization and most manipulation), and b: the manufacturers representation. You are pretty much forced down this route by your requirements. I would then add, for example, an ApplyTo(Instrument) method that applied the values on a name-to-name basis perhaps using serialization. I thing this will save you a lot of pain, especially if you abbreviate your properties to:

public float SomeSetting {get;set;}

This will allow you to work purely with your own model while offline. Spoofing the manfacturers model sounds unlikely, especially when mixed with serialization.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.