To use this code all you need to tie this object to your user interface is this:

// Create Binding with Class you want as the source of the binding
Binding := TObjectBinder.Create(TPerson);
// Binding() Parameters
// First: Property or Field of Class passed to the Constructor
// Second: Object you want as the destination of the binding.
// Third: Property or Field of the Destination you want to bind too
// Fourth: If the binding is readonly(Optional: Default False)
// Fifth: ITypeMapping Interface (Optional: Default NIL) more on this later.
Binding.Binding('FirstName',Edit1,'Text');
Binding.Binding('LastName',Edit2,'Text');
// Then there are two key methods you can use after that.
// Load() takes the contents of the Person and populates
// Edit1 and Edit2 Controls
Binding.Load(Person); // Where Person is an instance of TPerson
// This takes the contents of Edit1 and Edit2 and Saves it back to the person.
Binding.Save(Person);

What does this offer, allows you create a list of bindings of any property of any object
to any other property of any object. It reduces code like this...

Granted, if this was more than a prototype I would have built all of the common conversions
and automatically detected which one to use.

To take this further, I have a need to dynamically create a form that can edit an unknown object. Similar to what you can do with an Object Inspector, so this might work well to bind
to those dynamically create controls. Time to build another prototype :-)

Special thanks to Cobus Kruger for this great post and another option on doing the same thing. In that solution, I did not like having to name my controls to have to match my model. But the basic idea is very similar, and shows off yet another way to use the RTTI and potentially solve the same problem.

A critical requirement is that our model classes need to cross compile between .NET (Prism) and Win32. RemObjects SDK and DataAbstract where considered as they could have done this but I did not have 15k in my budget to justify buying this for my team.

Our DB persistence layer is nearing completing and is 100% .NET we communicate via a web service to our application.

We communicate between .NET and WIN32 using the same class model. Using the XmlSerializer I have posted before on the Win32 side, and the one built into the .NET Framework on our web service side.

So locally our models are persisted and stored in XML.

So ultimately we have one item left in our architecture that still needs some vetting. That is binding the user interface to the model. Which still has several optional solution and hence the need to develop prototypes.