DYNAMIC-CAST function

Returns a new object reference to the same class instance as an existing object reference, but with a different data type. This different data type is cast from the object type of the original object reference according to another object type specified by a run-time expression. The object types must be related, where one is a class type and the other is subclass of that class type or where one is an interface type and the other is a class that implements the interface of that type.

When you cast an object reference, ABL treats it as if it referenced an instance of the object type to which it is cast. The underlying class hierarchy of the object instance does not change.

DYNAMIC-CAST( `object-reference`, `expression` ).

An object reference defined with the object type to be cast.

A character expression that evaluates to the fully qualified type name for the ABL or .NET class or interface type to which the object reference is cast. This object type must be a class type in a class hierarchy that includes or implements the object-reference data type or it must be an interface type that the object-reference data type implements. However, the object type cannot be a .NET generic type. Specify an object type name using the syntax described in the Type-name syntax reference entry. Any present USING statement has no effect. If no package is specified, the class or interface name must represent the complete type name.

You typically cast an object reference down a class hierarchy—that is, from a super class to a derived class within a class hierarchy, or from an interface to a class that implements that interface. However, you do not always need to explicitly cast an object reference. Because a derived class contains all the super classes in its inherited class hierarchy, ABL implicitly casts any object reference up within its class hierarchy, and because a class that implements an interface implements all of the methods specified for the interface, ABL implicitly casts any object reference from an implementing class to any interface that the class implements.

At run time, ABL verifies that the object type specified by expression is within the class hierarchy of the specified object reference. Therefore, if you access a class member on the cast object reference that exists for the cast data type, but the referenced object does not actually define the accessed class member, the AVM raises a run-time ERROR.

A .NET generic type can be part of a cast. For example, you can cast from a System.Object to a "System.Collections.Generic.List<SHORT>", because all .NET classes, including generic classes, derive from the .NET root class. However, note that you cannot cast from a "System.Collections.Generic.List<System.Object>" to a "System.Collections.Generic.List<System.Windows.Forms.Button>". You cannot assign a "List<Button>" reference to an object reference defined as a "List<Object>", because, even though the type parameters are compatible, the two objects as a whole are not equivalent and have no inheritance relationship. Therefore, a cast between these two objects cannot work either. For more information on .NET generic types, see the Data types reference entry.

You can also use the CAST function to perform all casting operations at compile time. The primary reason for using the DYNAMIC-CAST function is to cast object references based on run-time conditions that determine the object type to use for the cast. Such conditions are common in applications that conform to the OpenEdge Reference Architecture (OERA). For more information on the OERA, see the Progress Software Developers Network (PSDN): http://communities.progress.com/pcom/community/psdn.

You can use the DYNAMIC-CAST function to cast a parameter in a parameter list for a method using the following syntax, where expression evaluates to a subclass of the object-reference type:


`method-name`( INPUT DYNAMIC-CAST( `object-reference`, `expression` ), ... ).

You can use the DYNAMIC-CAST function to cast a temp-table field, which is defined as a Progress.Lang.Object, to use as an object of another class type. For example:


DEFINE VARIABLE RCustObj AS CLASS acme.myObjs.CustObj. DEFINE TEMP-TABLE mytt NO-UNDO FIELD CustObj AS Progress.Lang.Object. RCustObj = DYNAMIC-CAST(mytt.CustObj, "acme.myObjs.CustObj").

You can now use the object reference in RCustObj to invoke methods in the acme.myObjs.CustObj class.

You cannot use the DYNAMIC-CAST function to cast an object reference to a subclass and invoke a method defined in that subclass using the following syntax:


DYNAMIC-CAST( `object-reference`, `object-type-name` ):`method-name`( `parameters` ).

Similarly, you cannot use this syntax to invoke a method on a class that implements the referenced interface from which you cast the specified class.