Simplest
way of explaining what Adaptor is, is probably using old fashioned
pointers. Those simply pointed on specific memory location and that was
it. Triggering data change was as simple as just by redirecting typed
pointer and data inside swapped for data from new location. But, .Net
is different in this because it doesn't support direct memory handling
and completely manages memory on its own. Difference between old
fashioned pointers and Adaptor types is that old fashioned pointers
still required a lot of after management. Adaptors and its clients are
data-aware which means that complete messaging about data notifications
is handled by it self without one single need to trigger the event.
Here
step in adaptors. Every Adaptor in System.Data.Bindings has few notable
properties, which define accessing data in completely new manner.
Target
- Assigning target is the same as assigning old fashioned memory
location since Adaptor can point to another Adaptor, which points to
another Adaptor and so on until one finally points to real data. And
since all adaptors are data aware they notify all connected parties
about data change that happened inside the last link in chain.
FinalTarget
- Resolves the final Target in chain and provides a nice way to access
currently edited data. Changing the FinalTarget behaviour is as simple
as overriding method DoGetFinalTarget in Adaptor subclass like in
MappedAdaptor class as example. Just to show practical value of
MappedAdaptor here is example.
class Company {
public Person Manager { get; set; } }
By
default it would mean a lot of hoops and tricks to update widgets to
new Manager values in specific windows which need to handle that
information. Or,... it was...
Here comes Adaptor, MappedAdaptor combo attack.
// Create MappedAdaptor with mapping to Manager
MappedAdaptor manager = new MappedAdaptor();
manager.Mappings = "Manager";
// Create adaptor which will serve as pointer to currently edited company
Adaptor company = new Adaptor();
// Point mapped adaptor to company adaptor
manager.Target = company;
Ok,
now this is where impressive starts to get mind blowing. Every widget
or System.Data.Bindings client connected to manager is notified
whenever company changes. In this way, anytime code specifies something like:
company.Target = somecompany;
all
connected widgets and other clients get updated on the fly. And if
company Adaptor points to object which doesn't have Manager property,
its Target will simply be null and notify widgets accordingly.
MappedAdaptor could as well point to another adaptor which would look something like this inside of class declaration
private IAdaptor ManagerAdaptor = new Adaptor(); public Person ManagerAdaptor { get { return (managerAdaptor); }
} public Person Manager { get { return ((Person) managerAdaptor.Target); } set { if (value != managerAdaptor.Target) managerAdaptor.Target = value;
} }
which
would mean a lot more flexibility inside of the class since now there
is active Adaptor for that property and MappedAdaptor can simply assign
Mappings = "ManagerAdaptor"
Mappings
- By default every Adaptor does not use Mappings. DataCursor enabled
adaptors don't handle them because they don't really need them. But
whenever Adaptor is invoked with DataCursor disabled, it handles
Mappings differently. Every value mapped is accessible and assignable
through its Values[] property if that is possible.
Conclusion:
That
mostly concludes this overly simplified view of Adaptor types, except
to point out again that there are two modes Adaptor can handle,
CursorMode and WidgetMode.
CursorMode is simply data pointer
WidgetMode (CursorMode=false) on the other hand handles all widget related operations.
Another
important feature is that Adaptor class is being specified with every
possible quirk in mind. For example, gtk needs all widget updates to be
handled in Gtk.Application.Invoke, which invokes that code in gtk
thread. So instead of having being carefull about threads GtkAdaptor,
GtkControlAdaptor take care of this. Data in DataSource can be assigned
in just about any thread, but in the end handling will always be in
correct one.
The
nicest example of CursorMode is CurrentSelection in item based widgets
like TreeView. By pointing Adaptor or DataSource to CurrentSelection
you get instant selection following and automated updates of controls.
|
