Calling 2 - Managed to Native

That can create some challenges when the calling language is different than the called language.

Mixing managed and native create some special problems as a variable is either managed or native, so data need to be converted when moving from one to another.

Common:

The example does not cover all aspects of calling from managed to native, but it does cover some of the more common.

Java:

JNI:

JNI (Java Native Interface) is the standard for how to call native code from a JVM language.

The API is a bit cumbersome to use and its usage require a C or C++ compiler to build a special DLL/so with a JVM friendly API.

Note that packagename1.packagename2.Classname.methodname becomes a function called Java_packagename1_packagename2_Classname_methodname.

Note that Java class names are specified like package1/package2/ClassName (not package1.package2.ClassName).

Note that Java method names are specified as methodname(argtypeargtype)returntype where types are I for int, Ljava/lang/String; for String, V for void etc..

Note that if function names become too long, then /name=(as_is,shortended) should be used and the options should be generated with @scan_globals_for_option.

Note that use of JNI is explicitly forbidden in the EJB spec. If JNI is needed in Java EE backend application, then it should be used in a JCA adapter - see here.

JNA:

JNA (Java Native Access) is a library that in the backend has a generic JNI API accessomg a standard DLL/so and in the frontend allow the developer to setup the specific native call in Java.

I could not get the two last examples (returning pointer to strict and modifying struct to work. It should be possible, but I was not able to make it work.

It is obvious that JNA replace some relative complex C code with some relative simple Java code and that is an obvious benefit for a Java developer.

There are many people that strongly prefer JNA over JNI. I am not so convinced. I will avoid native code if possible (when doing Java). If not possible then I would use JNI. JNI is a lot of work but there are no big unknowns - it will work. JNA seems to work fine for simple examples, but if one encounter a problem then one is stuck.

.NET:

P/Invoke or DllImport:

.NET has a very simple way of calling a C function in a DLL. The feature is called p/Invoke or DllImport.

In simple cases .NET can do the serialization/deserialization automatically. In more complex cases a little bit of custom code is needed.

When I first learned to use DllImport then I were a bit skeptical, but it actually works well. And since it is seeing some usage out in the real world, then it is well tested and easy to get help to.

C++/CLI mixed mode:

C++/CLI mixed mode is an convenient way to get from managed code to native code.

I think C++/CLI mixed mode is a very impressive technology. And I believe it is the most flexible way to integrate managed code and native code in .NET. But I must admit that it seems a little bit like black magic to me and I am not super comfortable relying on it.

Python:

ctypes:

Python comes with a module to call C functions in DLL/so. The module is named ctypes.

Change cdll.LoadLibrary('stddemolib.dll') to cdll.LoadLibrary('stddemolib.so') on *nix and to cdll.LoadLibrary('stddemolib') with a logical on VMS.

Windows COM:

Concept:

At the very lowest level a COM class is just a class implementing the interface IUnknown and following some conventions.

COM classes that need to support dynamic API explorartion must also implement the interface IDispatch. This is needed to support script languages without strong type system.

But this article will not focus on the lower levels - instead it will focus on how it practically can be used for cross language calls.

Server:

Since this article is about using COM not understanding the internals, then it will take the second approach as it is significant less code to write - and live with the fact that it is far from standard C++.

and we get a bunch of files including SNat.h with a C++ interface IS and a SNat.tlb type library, that will be used by languages with strong type system.

We define a class that use stuff from the generated files and the builtin support for COM.

Client:

We will see how to call the above COM component from C#, VB.NET, VBScript and JScript.

using System;

namespace COM
{
    public class MainClass
    {
        public static void Main(string[] args)
        {
            CoS cosnat = new CoSClass();
            IS snat = (IS)cosnat;
            int a = 123;
            int b = 456;
            int c = snat.Add(a, b);
            Console.WriteLine(c);
            string s = "ABC";
            string s2 = snat.Dup(s);
            Console.WriteLine(s2);
            snat.Iv = 123;
            snat.Sv = "ABC";
            snat.M();
            int iv = snat.Iv;
            string sv = snat.Sv;
            Console.WriteLine(iv + " " + sv);
        }
    }
}

Build:

tlbimp /out=SNatWrap.dll /namespace:COM SNat.tlb
csc /r:SNatWrap.dll C.cs

Output:

579
ABCABC
124 ABCX

Imports System

Namespace COM
    Public Class MainClass
        Public Shared Sub Main(args As String())
            Dim cosnat As CoS = New CoSClass()
            Dim snat As [IS] = DirectCast(cosnat, [IS])
            Dim a As Integer = 123
            Dim b As Integer = 456
            Dim c As Integer = snat.Add(a, b)
            Console.WriteLine(c)
            Dim s As String = "ABC"
            Dim s2 As String = snat.Dup(s)
            Console.WriteLine(s2)
            snat.Iv = 123
            snat.Sv = "ABC"
            snat.M()
            Dim iv As Integer = snat.Iv
            Dim sv As String = snat.Sv
            Console.WriteLine(iv & " " & sv)
        End Sub
    End Class
End Namespace

Build:

tlbimp /out=SNatWrap.dll /namespace:COM SNat.tlb
vbc /r:SNatWrap.dll C.vb

Output:

579
ABCABC
124 ABCX

using System;

namespace COM
{
    public class MainClass
    {
        public static void Main(string[] args)
        {
            dynamic sdn = Activator.CreateInstance(Type.GetTypeFromProgID("COM.SNat"));
            int a = 123;
            int b = 456;
            int c = sdn.Add(a, b);
            Console.WriteLine(c);
            string s = "ABC";
            string s2 = sdn.Dup(s);
            Console.WriteLine(s2);
            sdn.Iv = 123;
            sdn.Sv = "ABC";
            sdn.M();
            int iv = sdn.Iv;
            string sv = sdn.Sv;
            Console.WriteLine(iv + " " + sv);
        }
    }
}

Build:

csc CDyn.cs

Output:

579
ABCABC
124 ABCX

Option Strict Off

Imports System

Namespace COM
    Public Class MainClass
        Public Shared Sub Main(args As String())
            Dim sdn As Object = Activator.CreateInstance(Type.GetTypeFromProgID("COM.SNat"))
            Dim a As Integer = 123
            Dim b As Integer = 456
            Dim c As Integer = sdn.Add(a, b)
            Console.WriteLine(c)
            Dim s As String = "ABC"
            Dim s2 As String = sdn.Dup(s)
            Console.WriteLine(s2)
            sdn.Iv = 123
            sdn.Sv = "ABC"
            sdn.M()
            Dim iv As Integer = sdn.Iv
            Dim sv As String = sdn.Sv
            Console.WriteLine(iv & " " & sv)
        End Sub
    End Class
End Namespace

Build:

vbc CDyn.vb

Output:

579
ABCABC
124 ABCX

Set sdn = CreateObject("COM.SNat")
a = 123
b = 456
c = sdn.Add(a, b)
WScript.Echo CStr(c)
s = "ABC"
s2 = sdn.Dup(s)
WScript.Echo s2
sdn.Iv = 123
sdn.Sv = "ABC"
call sdn.M
iv = sdn.Iv
sv = sdn.Sv
WScript.Echo CStr(iv) & " " & sv 
Set sdn = Nothing

Run:

cscript c.vbs

Output:

579
ABCABC
124 ABCX

var sdn = new ActiveXObject("COM.SNat");
var a = 123;
var b = 456;
var c = sdn.Add(a, b);
WScript.Echo(c);
var s = "ABC";
var s2 = sdn.Dup(s);
WScript.Echo(s2);
sdn.Iv = 123;
sdn.Sv = "ABC";
sdn.M();
var iv = sdn.Iv;
var sv = sdn.Sv;
WScript.Echo(iv + " " + sv); 
sdn = null;

Run:

cscript c.js

Output:

579
ABCABC
124 ABCX

The old Microsoft Java came with support for COM.

Other Java implementations and that include all recent does not support COM. But an open source project Jacob adds the capability.

Strictly speaking Jacob does not call COM from Java. Strictly speaking Jacob use JNI to call some C/C++ code in a DLL that then call COM. But from a practical developer perspective Jacob "calls" COM.

Jacob provide two classes for calling COM:

Dispatch: procedural style
ActiveXCompnent: object orieneted style

Both as names indicateuse IDispatch and dynamic API.

This is Dispatch:

import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

public class C1 {
    public static void main(String[] args) {
        Dispatch snat = new Dispatch("COM.SNat");
        int a = 123;
        int b = 456;
        int c = Dispatch.callN(snat, "Add", new Variant(a), new Variant(b)).getInt();
        System.out.println(c);
        String s = "ABC";
        String s2 = Dispatch.callN(snat, "Dup", new Variant(s)).getString();
        System.out.println(s2);
        Dispatch.put(snat, "Iv", new Variant(123));
        Dispatch.put(snat, "Sv", new Variant("ABC"));
        Dispatch.callN(snat, "M");
        int iv = Dispatch.get(snat, "Iv").getInt();
        String sv = Dispatch.get(snat, "Sv").getString();
        System.out.println(iv + " " + sv);
    }
}

Build and run:

javac -cp %JACOBDIR%\jacob.jar C1.java
java -Djava.library.path=%JACOBDIR% -cp .;%JACOBDIR%\jacob.jar C1

Output:

579
ABCABC
124 ABCX

The old Microsoft Java came with support for COM.

Other Java implementations and that include all recent does not support COM. But an open source project Jacob adds the capability.

Strictly speaking Jacob does not call COM from Java. Strictly speaking Jacob use JNI to call some C/C++ code in a DLL that then call COM. But from a practical developer perspective Jacob "calls" COM.

Jacob provide two classes for calling COM:

Dispatch: procedural style
ActiveXCompnent: object orieneted style

Both as names indicate use IDispatch and dynamic API.

This is ActiveXComponent:

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Variant;

public class C2 {
    public static void main(String[] args) {
        ActiveXComponent snat = new ActiveXComponent("COM.SNat");
        int a = 123;
        int b = 456;
        int c = snat.invoke("Add", new Variant(a), new Variant(b)).getInt();
        System.out.println(c);
        String s = "ABC";
        String s2 = snat.invoke("Dup", new Variant(s)).getString();
        System.out.println(s2);
        snat.setProperty("Iv", 123);
        snat.setProperty("Sv", "ABC");
        snat.invoke("M");
        int iv = snat.getPropertyAsInt("Iv");
        String sv = snat.getPropertyAsString("Sv");
        System.out.println(iv + " " + sv);
    }
}

Build and run:

javac -cp %JACOBDIR%\jacob.jar C2.java
java -Djava.library.path=%JACOBDIR% -cp .;%JACOBDIR%\jacob.jar C2

Output:

579
ABCABC
124 ABCX

Version	Date	Description
1.0	February 2nd 2020	Initial version
1.1	February 9th 2020	Add Windows COM
1.2	February 22nd 2020	Add Java Jacob

Calling 2 - Managed to Native

Content:

Introduction:

Common:

Java:

JNI:

JNA:

.NET:

P/Invoke or DllImport:

C++/CLI mixed mode:

Python:

ctypes:

Windows COM:

Concept:

Server:

Client:

Article history:

Other articles:

Comments: