Skip to main content
Previous sectionNext section

Using .NET Reverse Proxy Objects

The Native API works together with the Object Gateway for .NET. Reverse proxy objects are .NET objects that allow you to manipulate ObjectScript objects via the Object Gateway. You can use a reverse proxy object to call the target’s instance methods and get or set property values, manipulating the ObjectScript target object as easily as if it were a native .NET object.

This chapter covers the following topics:

Introducing the Object Gateway

The Object Gateway allows InterSystems IRIS objects and .NET objects to interact freely, using the same connection and working together in the same context (database, session, and transaction). Object Gateway architecture is described in detail in Using the Object Gateway for .NET, but for the purposes of this discussion you can think of it as a simple black box connecting proxy objects on one side to target objects on the other:

Object Gateway System
Object gateway connecting ObjectScript application on InterSystems IRIS with .NET application on host VM

The connection is via TCP/IP if InterSystems IRIS and the host VM are on two different machines. If they are on the same machine, the connection can be either TCP/IP or shared memory.

As the diagram shows, a forward proxy object is an ObjectScript proxy for a .NET target object (see “Using Dynamic Object Proxies” in Using the Object Gateway for .NET for details). Forward proxies will be mentioned again later, but the focus of this chapter is how to use a .NET reverse proxy to manipulate an ObjectScript target object.

Creating Reverse Proxy Objects

You can create a reverse proxy object by obtaining the OREF of an ObjectScript class instance (for example, by calling the %New() method of the class) and casting it to IRISObject. The following methods can be used to call ObjectScript class methods and functions:

In either case, if the returned object is a valid OREF, it will be used to generate and return a proxy for the referenced object.

See “Class Method Calls” in the previous chapter for more information on how to call ObjectScript class methods. The following example uses ClassMethodObject() to create a reverse proxy object:

Creating an instance of IRISObject
  • ClassMethodObject() is used to call the %New() method of an ObjectScript class named Demo.Test.

  • Since the return value of %New() is a valid OREF, ClassMethodObject() creates and returns a proxy for the instance.

  • In .NET, the proxy is cast to IRISObject, creating reverse proxy object test:

       IRISObject test = (IRISObject)iris.ClassMethodObject("Demo.Test","%New");
Copy code to clipboard

Variable test is a .NET reverse proxy object for the new instance of Demo.Test. In the following section, test will be used to access methods and properties of the ObjectScript Demo.Test instance.

Using IRISObject Methods

IRISObject provides methods to access the ObjectScript target object. The following example uses Invoke() and InvokeVoid() to call instance methods, and accessors Get() and Set() to get and set a property value.

The example in this section uses reverse proxy object methods to access an ObjectScript class named Demo.Test, which includes declarations for methods initialize() and add(), and property name:

ObjectScript Class Demo.Test
   Class Demo.Test Extends %Persistent
      Method initialize(initialVal As %String)
      Method add(val1 As %Integer, val2 As %Integer) As %Integer
      Property name As %String
Copy code to clipboard

In the following example, the first line creates a reverse proxy object named test for an instance of Demo.Test. The rest of the code uses proxy object test to access the Demo.Test instance.

.NET code using a Demo.Test reverse proxy object
// Create an instance of Demo.Test and return a proxy object for it
  IRISObject test = (IRISObject)iris.ClassMethodObject("Demo.Test","%New");

// instance method test.initialize() is called with one argument, returning nothing.
  test.InvokeVoid("initialize", 42);  // sets a mysterious internal variable to 42

// instance method test.add() is called with two arguments, returning an int value.
  int sum = test.Invoke("add",2,3);  // adds 2 plus 3, returning 5

// The value of property is set and then returned.
  test.Set("name", "Einstein, Albert");  // sets the property to "Einstein, Albert"
  String name = test.Get("name");   // returns the new property value
Copy code to clipboard

This example used the following IRISObject methods to access methods and properties of the Demo.Test instance:

There are also datatype-specific versions of these methods, as described in the following section.

IRISObject Supported Datatypes

The example in the previous section used the generic Set(), Get(), and Invoke() methods, but the IRISObject class also provides datatype-specific methods for other supported datatypes.

IRISObject set() and get() methods

The IRISObject.Set() method accepts any Java object as a property value, including all datatypes supported by IRIS.Set() (see “Class IRIS Supported Datatypes”).

In addition to the generic Get() method, IRISObject provides the following type-specific methods: GetBool(), GetBytes(), GetDouble(), GetIRISList(), GetLong(), GetObject() and GetString().

IRISObject invoke() methods

The IRISObject invoke methods support the same set of datatypes as the IRIS classmethod calls (see “Class Method Calls”).

In addition to the generic Invoke() method, IRISObject provides the following type-specific methods: InvokeBool(), InvokeBytes(), InvokeDouble(), InvokeIRISList(), InvokeLong(), InvokeObject(), InvokeString(), and InvokeVoid(). It also provides InvokeStatusCode(), which gets the contents of an ObjectScript %Status return value (see “Catching %Status Error Codes”).

All of the invoke methods take a String argument for methodName plus 0 or more method arguments, which may be any of the following types int?, short?, string, long?, double?, float?, byte[], bool?, DateTime?, IRISList?, or IRISObject. If the connection is bidirectional, any Java object can be used as an argument.

Trailing arguments may be omitted in argument lists, either by passing fewer than the full number of arguments, or by passing null for trailing arguments. An exception will be thrown if a non-null argument is passed to the right of a null argument.

FeedbackOpens in a new window