(WinForms) Encapsulate a 3rd Party control in a UserControl, but still access it's Design-Time Designer?

I'm trying to find ways to decouple our code from a long-standing dependency on a specific 3rd party grid control (which we would like to replace as it's old and discontinued).

What I would like to do it follow my usual rule for 3rd party code -- wrap it in my own code and keep it decoupled from the rest of our code, so it is effectively decoupled from our code and hence becomes easy to change.

What I want to be able to do is create a UserControl that contains the 3rd party grid and make all code reference the UserControl, passing relevant calls and event to the internally held 3rd party control (that way I could replace the contained grid with some other grid without disrupting the rest of the UI code).

However, if I do this than I lose the design-time access to the contained grid's properties (which we use quite a lot).  What I want to be able to do is add design-time attributes to my UserControl but have them 'pass through' to the 3rd party control it contains.

Any thoughts?

Herbie

Pardon the rather knee-jerk reply (can't spend too much time in the forums)

I wonder whether what you're trying to do *really* decouples your code. Have you considered biting the bullet and just replacing the third-part control?

edit: fixed type-O

I think it will require the UserControl inherit from the 3rd party control rather than the 3rd party control be a child control within the UserControl.  I've reviewed something similar we did as well and it does appear that the designer use was no longer possible; however, the Properties listing was still available.

@ScottWelker: We use this grid in 120 different forms in each of 4 projects (giving nearly 500 to be replaced in total), each with a different layout.  We currently inherit from the grid into our own version which adds missing functionality we use.  We're going to have to take the pain of altering all 120 forms whatever we do because they are currently coupled to the specific grid; it stores layout details in the form resources as a property bag so we can't just search and replace the typename without having to manually strip out the old layout info and re-do them for the new grid.  If we're going to go through the pain of a replacement, I'd like to be able to avoid another round of pain in a few years if we have to replace the grid a second time. I have successfully done this for a Gantt chart control, but we don't use the visual designers for that, it's all done in code.

@davewill: As mentioned above, inheriting into our own grid is exactly what we do at the moment.  I want to move from inheritance to encapsulation, but add a designer to the UserControl that actually passes off to the encapsulated grid's designer.  I did experiment with a DynamicDesigner<T> which extracted the designer type of the templated class and passed all calls to it, but that was not enough to get it to work.

Herbie

@Dr Herbie: In order to encapsulate, the encapsulator is going to have to expose its own independent surface (properties, methods, designer, etc.).  Which you have stated, except for wanting to avoid the work of creating the UserControl designer portion.  Having the UserControl expose a designer based on the 3rd party it currently contains would be contrary to the goal though as the consumers of the UserControl now may contain specifics tied to the 3rd party that would have to be revisited when a new 3rd party is put in place.  Right?

What I had originally thought of was that we would update the exposed designer when we updated the grid internally, but I guess that would mean that all the layout detail would have to be re-done anyway.

Hmm.

I guess we would have to implement our own control, with it's own designer, storing layout in our own way, but them 'translating' it all to the encapsulated grid.  Sounds nasty and more trouble than it's worth.

Oh well.

Thanks for your input.

Herbie