Binding properties pattern

Last updated

The binding properties pattern is combining multiple observers to force properties in different objects to be synchronized or coordinated in some way. This pattern was first described as a technique by Victor Porton. [1] [2] This pattern comes under concurrency patterns.

Contents

Comparison with aspect-oriented implementation

As an alternative to the aspect-oriented implementation of mutual properties, property binding can be proposed. In LibPropC++ C++ library it is implemented too. [3]

Some weakness in the LibPropC++ (with property binding):

  1. Its use is not transparent as it requires to be declared necessary object attributes as properties and appropriate accessor methods must be provided
  2. Binding of attributes in LibPropC++ is not designed to replace method calls
  3. The library does not maintain an interaction history. [3]

Implementation

There are two types of binding. One-way binding should be applied when one of the properties is read-only. In other cases, two-way binding must be applied. [2] [3]

Infinite loops can be eliminated by blocking the signal, or comparing the assigned value with the property value before assignment, or eliminating unnecessary assignments. [2] [3]

Binding properties of different types can be achieved through type conversions. [2] [3]

Binding properties with transformations can be achieved through reducing the transformation function to the problem of binding properties, and the function can be imaginary consider as Type Conversions. [2] [3]

Procedural programming
Object-oriented programming
Signals/event programming
Components with properties
binding properties together

[2]

Resulting context

Properties are being kept synchronized automatically. Between library calls they always have the values expressed by the EqualityConstraints. [3]

Deficiencies

Property changes watching mechanism acquires some resources. [3]

Sample code

Code sketch for one-way binding may look like as follows:

bind_multiple_one_way(src_obj,src_prop,dst_objs[],dst_props[]){for(i,j)in(dst_objs,dst_props){bind_properties_one_way(src_obj,src_prop,i,j);}}

[2]

Two-way binding can be expressed as follows (in C++):

// In this pseudo-code are not taken into the account initial values assignmentsbind_two_way(prop1,prop2){bind(prop1,prop2);bind(prop2,prop1);}

[3]

Accomplishing the binding (i.e. connecting the property change notification in an event handler) may be like as follows:

on_property_change(src_prop,dst_prop){block_signal(src_obj,on_property_change);dst_prop:=src_prop;unblock_signal(src_obj,on_property_change);}

[3]

See also

References

  1. ↑ "Binding Properties". Cunningham & Cunningham. Cunningham & Cunningham. Retrieved 4 February 2015.
  2. 1 2 3 4 5 6 7 Porton, V. "Binding together Properties of Objects". Victor Porton. Retrieved 25 February 2021.
  3. 1 2 3 4 5 6 7 8 9 10 Evermann, J., The Association Construct in Conceptual Modelling - An Analysis Using the Bunge Ontological Model, Wellington, New Zealand: School of Information Management, Victoria University
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.