DYNAMIC-NEW statement

Creates an instance of a class (object) whose class type is specified by a run-time expression, and assigns its object reference to an appropriately defined ABL data element. Once assigned, you can use the object reference to access this class instance and its PUBLIC data members, properties, and methods. For more information on object references, see the reference entry for a Class-based object reference.

Syntax

object-reference = DYNAMIC-NEW expression 
  ( [ parameter [ , parameter ]... ] ) [ NO-ERROR ]

object-reference

The name of an ABL data element to which you want to assign the object reference of a new instance of the class specified by expression. This data element must be defined as a compatible class or interface type, and can be one of the following:

• A temp-table field defined as a Progress.Lang.Object class type using the DEFINE TEMP-TABLE statement
• A variable scoped to the current procedure, user-defined function, or method of a class, or an accessible class-based variable data member, each defined as a class or interface type using the DEFINE VARIABLE statement
• A parameter defined as a class or interface type for the current procedure, user-defined function, or method of a class using an appropriate DEFINE PARAMETER statement or Parameter definition syntax
• An accessible and writable class-based property defined as a class or interface type using the DEFINE PROPERTY statement

To be compatible, the data type of object-reference must be:

• The same class as the class specified by expression
• A super class of the class specified by expression
• An interface that is implemented by the class specified by expression

expression

A character expression that evaluates to a fully qualified class type name for the ABL or .NET class you want to instantiate. This expression must specify a class type name as described in the Type-name syntax reference entry, except that you must always specify the complete type name; any present USING statement has no effect. If no package (or namespace for a .NET class) is specified, the class name must represent the complete type name.

This expression cannot evaluate to:

• An ABL built-in class type name, such as Progress.Lang.Object
• The type name of an interface or abstract class

( [ parameter [ , parameter ]... ] )

Specifies zero or more parameters passed to a PUBLIC instance constructor that is defined for the class. You must provide the parameters identified by the specified constructor, matched with respect to number, data type, and mode.

For information on the parameter passing syntax, see the Parameter passing syntax reference entry.

For information on defining a constructor for a class, see the CONSTRUCTOR statement reference entry.

NO-ERROR

The NO-ERROR option is used to prevent the statement from raising ERROR and displaying error messages.

For the DYNAMIC-NEW statement with NO-ERROR, if ERROR is raised, then the object-reference remains unchanged.

Example

The following contrived (non-compiling) procedure fragment shows the instantiation of a new class type specified with a variable:

/* Can be set to a subclass type name */
DEFINE INPUT PARAMETER myBusObjParm AS CHARACTER NO-UNDO.

/* Procedure only knows about the base class */
DEFINE VARIABLE myBusObj AS CLASS acme.myObjs.BusObj NO-UNDO.

myBusObj = DYNAMIC-NEW myBusObjParm ( ). /* Create the passed subclass */
 myBusObj:getData( ).                    /* Invoke base class method
                                             polymorphically on subclass */

In this case, the procedure assumes that it is operating on a class, acme.myObjs.BusObj, that is the base class for several subclasses, each of which implements the same set of operations for its own purposes, such as the getData( ) method shown. When the procedure is called, its INPUT parameter is passed a character string that evaluates to a subclass type name, such as "acme.myObjs.CustObj", which it then uses to instantiate a class of that type using the DYNAMIC-NEW statement. Thus, the same procedure can be called to instantiate and operate on different subclasses of the same base class, as determined by run-time conditions.

Notes

• Unlike NEW, you cannot use DYNAMIC-NEW as a function in an expression. You can use it only as a statement.
• After the assignment, object-reference contains a copy of the object reference value returned by DYNAMIC-NEW, which points to the same object instance, not a copy of the object created by DYNAMIC-NEW.
• Although you can assign an object reference to a temp-table field defined as a Progress.Lang.Object class type, you cannot assign an object reference to a field in a database table. For more information, see OpenEdge Development: Object-oriented Programming.
• The ABL Virtual Machine (AVM) automatically deletes (garbage collects) any class instance that you create with this statement some time after no reference to that object exists in the ABL session. However, you can force any class instance to be deleted immediately by using the DELETE OBJECT statement. For more information on garbage collection for class instances, see the DELETE OBJECT statement reference entry.
• If expression specifies a .NET object, note that in ABL you cannot instantiate the following .NET classes:
  • Any .NET class that is defined in the default namespace, that is, where the class name is the complete object type name
  • System.Threading.Thread or any class derived from it
  • System.Delegate or any delegate type derived from it
• If expression specifies a GUI or non-GUI .NET object type, you can instantiate it within a non-GUI ABL session on Windows, including a:
  • Character mode (CHUI) client
  • Batch-mode client
  • AppServer agent session
  • WebSpeed agent session

  However, you cannot block for any .NET object events or visualize any GUI objects in a non-GUI ABL session.

• This statement can raise errors during the execution of constructors for the class being instantiated, or for any class in its inherited class hierarchy. For example:
  • A constructor in the class hierarchy executes the RETURN statement with the ERROR option or the UNDO statement with the THROW or RETURN ERROR options.
  • The class definition file for the class, a super class, or an interface could not be found.
  • The run-time parameters of the constructor for the class, or a constructor for a class in the inherited class hierarchy, are not compatible.

  When the AVM encounters one of these errors, and the constructor cannot create the class instance or its inherited class hierarchy, the AVM automatically invokes the destructor for any class that has already been constructed while building the class hierarchy for the object.

  For more information on errors raised by instantiating classes, see OpenEdge Development: Object-oriented Programming.

• The New( ) method of the Progress.Lang.Class class provides similar functionality to the DYNAMIC-NEW function. The advantage to the latter is that it has a fixed, compile-time parameter list and does not require the creation of a Progress.Lang.ParameterList object at run time.

See also

Assignment (=) statement, Class-based object reference, CLASS statement, DYNAMIC-CAST function, DYNAMIC-INVOKE function, Invoke( ) method (Class), NEW function (classes), New( ) method, NEW statement, NO-ERROR option, Parameter passing syntax, Progress.Lang.ParameterList class