Meta Resource Management System

To write a class that can be used with .NET Remoting the only thing you have to do is to implement the marker interface MarshalByRefObject.

using System;

namespace remotingTypes {
  public class MyService : MarshalByRefObject {
    public MyService() {
      Console.WriteLine("Instance of MyService created.");
    }

    ~MyService() {
      Console.WriteLine("Instance of MyService deleted.");
    }

    public DateTime getServerTime() {
      Console.WriteLine("getServerTime() invoked");
      return DateTime.Now;
    }

    public MyType getMyType() {
      return new MyType("Hello Java!", 1234);
    }

    public int add(int x, int y) {
      return x + y;
    }
  }
}

The service above contains a method named getMyType() which returns an object of the type MyType. It is shown in the following listing.

using System;

namespace remotingTypes {
  [Serializable] public class MyType { // passed by value
  // public class MyType : MarshalByRefObject { // passed by reference
    public string content;
    public int number;

    public MyType(string content, int number) {
      this.content = content;
      this.number = number;
    }

    public string getTestContent() {
      return content;
    }

    public void remoteMethod() {
      Console.WriteLine("remoteMethod() invoked.");
    }
  }
}

To make the service available we need to have a server process that opens a channel, registers the type MyService as a server remoting type and keeps running until the user the stops it (in our example by pressing enter). Then, the service is reachable via the URI http://localhost:8082/object1uri and its Web Service Description Language (WSDL) file can be downloaded from http://localhost:8082/object1uri?wsdl.

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using remotingTypes;

namespace remotingServer {

  class ServerProcess {
    [STAThread]
    static void Main(string[] args) {
      IChannel channel = new HttpChannel(8082);
      ChannelServices.RegisterChannel(channel);

      MyService object1 = new MyService();
      ObjRef refl = RemotingServices.Marshal(object1, "object1uri");
      Console.WriteLine("URI: " + refl.URI);

      Console.WriteLine("Press enter to end.");
      Console.ReadLine();

      RemotingServices.Disconnect(object1);
      ChannelServices.UnregisterChannel(channel);

      GC.Collect();
      GC.WaitForPendingFinalizers();
    }
  }
}

We wrote a little tester that connects to the server process and invokes some methods. The call of object1.getMyType().remoteMethod() which prints out the string "remoteMethod() invoked." shows the difference between parameters and return values passed by reference and passed by value. If MyType is declared as "[Serializable] public class MyType", object1.getMyType() returns an object of type MyType by value and the string is printed out on the client. If MyType is declared as "public class MyType : MarshalByRefObject", object1.getMyType() returns a remote reference to an object on the server and the string is printed out on the server.

We tested the performance of the HttpChannel and the SoapFormatter by making 1000 successive calls: It took less than five seconds, thus it took less than five milliseconds per call which we consider to be fast enough.

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using remotingTypes;

namespace remotingClient {
  class ClientProcess {
    [STAThread]
    static void Main(string[] args) {
      IChannel channel = new HttpChannel();
      ChannelServices.RegisterChannel(channel);
      
      RemotingConfiguration.RegisterWellKnownClientType(
        typeof(MyService), "http://localhost:8082/object1uri");
            
      MyService object1 = new MyService();
      if (object1 == null) {
        Console.WriteLine("Could not locate server.");
        return;
      }
      
      Console.WriteLine("ServerTime: " + object1.getServerTime());
      object1.getMyType().remoteMethod(); 

      int x = 0;
      DateTime start = DateTime.UtcNow;
      for (int i = 0; i < 1000; ++i) {
        x = object1.add(x, i);
      }
      Console.WriteLine("x: " + x);
      DateTime end = DateTime.UtcNow;
      Console.WriteLine("Time: " + (end-start).ToString());

      Console.ReadLine();
    }
  }
}

We also wanted to check whether we could connect to the .NET server process via Java: We downloaded the WSDL file and used the WSDL2Java tool from the Axis project (http://ws.apache.org/axis/) to create Java stubs from it. It worked, even only a little bit slower than the .NET client (the 1000 calls took 6.7 seconds), but: the parameters and return values can only be passed by value and their types may only contain public properties (no methods).

public class Tester {
  public static void main(String[] args)
    throws MalformedURLException, ServiceException, RemoteException {
    MyServiceService service = new MyServiceServiceLocator();

    // Now use the service to get a stub which implements the SDI.
    MyServicePortType port = service.getMyServicePort();

    System.out.println("Got port.");

    System.out.println("Server time: " + port.getServerTime());
    MyType myType = port.getMyType();
    System.out.println("Content: " + myType.getContent());
    System.out.println("Number: " + myType.getNumber());
    System.out.println("3 + 5 = " + port.add(3, 5));

    int x = 0;
    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000; ++i) {
      x = port.add(x, i);
    }
    System.out.println("x: " + x);
    long end = System.currentTimeMillis();
    System.out.println("Time [ms]: " + (end - start));
  }
}

.NET Remoting is powerful, fast and easy to use. It is interoperable with Java to a certain degree: If we only use simple data container types that act like structs we can use the service with Java.