Adding flexibility and facilitating object reuse
You can use exception handling to add flexibility to your
PowerBuilder applications, and to help in the separation of business
rules from presentation logic. For example, business rules can be stored
in a non-visual object (nvo) that has:
-
An instance variable to hold a reference to the presentation
object:1powerobject my_presenter -
A function that registers the presentation object
The registration function could use the following
syntax:1SetObject (string my_purpose, powerobject myobject) -
Code to call a dynamic function implemented by the
presentation object, with minimal assumptions about how the data is
displayedThe dynamic function call should be enclosed in a try-catch
block, such as:12345TRYmy_presenter.Dynamic nf_displayScreen(" ")CATCH (Throwable lth_exception)Throw lth_exceptionEND TRYThis try-catch block catches all system and user-defined
errors from the presentation object and throws them back up the
calling chain (to the object that called the nvo). In the above
example, the thrown object in the CATCH statement is an object of
type Throwable, but you could also instantiate and throw a user
exception object:12345678910uo_exception luo_exceptionTRYmy_presenter.Dynamic nf_displayScreen(" ")CATCH (Throwable lth_exception)luo_exception = Create uo_exceptionluo_exception.SetMessage & +(lth_exception.GetMessage())Throw luo_exceptionEND TRY
Code for data processing could be added to the presentation
object, to the business rules nvo, or to processing objects called by
the nvo. The exact design depends on your business objectives, but this
code should also be surrounded by try-catch blocks. The actions to take
and the error messages to report (in case of code processing failure)
should be as specific as possible in the try-catch blocks that surround
the processing code.
There are significant advantages to this type of approach, since
the business nvo can be reused more easily, and it can be accessed by
objects that display the same business data in many different ways. The
addition of exception handling makes this approach much more robust,
giving the application user a chance to recover from an error
condition.