Copyright 2004 by Codemesh, Inc. All Rights Reserved Welcome Jini in a.NET Environment by Alexander Krapf Jini Community Meeting Cambridge March 23-35,

Copyright 2004 by Codemesh, Inc. All Rights Reserved

Welcome

Jini in a .NET Environment

by

Alexander Krapf

Jini Community MeetingCambridge

March 23-35, 2004


Speaker

Co-founder & President of Codemesh, Inc.

16 years of C++ development experience

7 years of Java development experience

2 years of .NET experience 5 years of integration of Java with other languages


Agenda

Why should I care about .NET?

General Integration Approaches

What makes Jini a special case?

Integration Details

Type Mapping

Integration Architecture

P/Invoke & JNI

Demonstration

Q & A


Why would I want to do that ?

Jini and .NET


Jini and .NET ... Why?

Because .NET is becoming the de-facto standard for Microsoft centric development

Because .NET has nothing like Jini

Because .NET does have some redeeming features



Because we’re not religious about technology. We mix and match where appropriate!

Because we want Jini to succeed, and for that it can’t be seen as Java-only

Because we benefit from promoting Java “guts” technologies to .NET users



Because I would hate to see distributed computing dominated by J2EE and Web Services

Because not everyone develops software in Java


What does an integration look like?

Example 1: JavaSpaces

JavaSpace JavaSpace

Java Servers

Java Client

VB.NET Client

C# Client


What does an integration look like?

Example 2: Service Oriented Architecture

Jini Service

C# Client

Java Client

Not a very exciting slide, but an exciting design!

VB Client


OK, I buy the occasional need, but what exactly

does “Jini and .NET” mean ?

Jini and .NET


Definition of Java

What is the Java platform?

JVM Spec

Language Spec

Class Libraries

Runtime Environment


Definition of .NET

What is the .NET platform?

CLR

CTS

CLS

CIL

C#Language

Spec

VB.NETLanguage

Spec

mC++Language

Spec

HostSpec

CLR: Common Language Runtime

CIL: Common Intermediate Language

CTS: Common Type System

CLS: Common Language Specification


What we really want

Define the goals

Write C#, VB, C++, etc. source code that “links with” arbitrary Jini code easily

Use all important Jini features from .NET, including callbacks

Impose no prohibitive performance penalty

Write C#, VB, C++, etc. source code that allows natural use of all native features


What we really want (cont.)

[STAThread]static void Main(string[] args){ Hashtable ht = new Hashtable();

ht.put( Context.PROVIDER_URL, “file://mydir” ); ht.put( Context.INITIAL_CONTEXT_FACTORY, “MyICtx” );

InitialContext ictx = new InitialContext( ht ); Context ctx = (Context)ictx.lookup( “test” );

… }

Write C# code like this:


What we really want (cont.)

[STAThread]static void Main(string[] args){ Hashtable ht = new Hashtable();

ht.put( Context.PROVIDER_URL, “file://mydir” ); ht.put( Context.INITIAL_CONTEXT_FACTORY, “MyICtx” );

InitialContext ictx = new InitialContext( ht ); Context ctx = (Context)ictx.lookup( “test” );

… }

Lots of Problems in a short snippet!


The Jini twist on theJava/.NET integration

problem…

Jini and .NET


Application

Why it is a hard problem…

Jini leverages Java!

RMI/code mobility

Security/Classloaders

Platformindependence

JINI

Application #2Application #1


Integrating Jini with .NET ... How?

Must accommodate downloaded code

Must support RMI

Must support Java and Jini security

Must support callbacks

Technical Requirements


Integrating Jini with .NET ... How?

Serialization/Message-based:

CORBA, Webservices, MOM, custom

Translation-based:

Java to C#, Bytecode to IL

Proxy-based:

Java Native Interface

managed C++ or PInvoke

Architectural Alternatives


Serialization/Message-Based

CORBA

WebServices

MOM

Custom

- database

- filesystem

- sockets


Serialization/Message-Based

Different technologies, same principles

- argument/result serialization through

IIOP, SOAP, XML, ...

- object/service discovery through

naming service, UDDI, custom registries

- several processes or “objects” involved

Java process, .NET process,

file locks, table rows, helpers


Translation-Based Integration

Large set of classes involvedtransitive closure for Object: ~ 260 classes

Still need JRE or reimplementation of all native libraries

IL is very different from JVM bytecode

Interface/Implementation designs are problematic

Reflection, Class.forName() are problematic

Promising at first, but very problematic

“Stale bits” are uncheckable and out-of-date


Proxy-Based Solution

Jini Example

Java Server

Service

.NET Client

Proxy’

RuntimeLibrary

Service

JVM

Proxy

ProxyProxy’

Client Process Server Process



JVM C

JNI

DLL

GeneratedProxy

Classes(C#)

C#

PInvoke

assembly

API

.NETUser

Architectural Diagram



Performance Characteristics

Design and Implementation have huge impact on performance

0-200% overhead, depending on application

Negligible overhead in most applications

up to 25% overhead in most others

Strings can be relatively costly



xcopy Deployment

<myapp>

bin application binaries and config files

lib application Java classes (jar,zip)

jre private Java runtime environment



Threading Model

public static void main(String[] args ){ Runnable r = new MyRunnable();

…

new Thread( r ).start();

…}

How does this code behave in Java and in .NET ?


Type Mapping

The Common Language Runtime

provides access to

the .NET class library or

libraries that are based upon it

using the language bindings of your choice.

What about the Java class library?


Type Mapping

General Issues

Both platforms have object models

Slightly incompatible specifications

Both platforms have class libraries

Typenames are duplicated

Different Naming Policies


Object Model Mapping

class to class

interface to interface

constructor to constructor

method to method

field to property

Overall a good match



conflicting Array models

conflicting Exception models

cannot declare static members for interfaces (CLS)

CLS has more restrictive naming than Java

But there are problems



both sides use garbage collection

JNI references need to be freed explicitly

IDisposable together with finalization offer what we need

Care required with callbacks!

Object Lifecycle



Classes

Java .NET

Object

String Throwable

Exception

RuntimeException

Error

Object

String Exception

ApplicationException

SystemException


Custom TypeCustom Type

Custom Type

CustomExceptionCustom

ExceptionCustomException

Type System Mapping

.NET with mapped Java Types

Object

Throwable

Exception

RuntimeException

Error

Object

String Exception

ApplicationException

SystemException

String

Neither Strings nor Throwablesare Java Objects anymore!



Java proxy types should extend proxy Object type (with exceptions)

Every proxy type must be usable in all places where Java Object is legal

Object Requirements



.NET string literals must be usable in places where Java strings are expected

.NET string literals must be usable in places where Java strings are legal

String Requirements

Object put( Object key, Object value )

String getProperty( String name )



java.lang.String must map to System.String because of literals

Large impact on Object-type elements

String Mapping

Object put( Object key, Object value )

becomes

object put( object key, object value )



interface types must be usable in all places where Java uses the Object type

interface inheritance (multiple interfaces, directly and indirectly)

static interface elements

polymorphic use (concrete object used through interface type)

Interface Requirements



Every Java interface maps to a .NET interface and a .NET class

.NET interface type used for declarations

.NET class type used for instantiation of proxy objects and to hold static elements

Which one gets the natural name?

Interface Mapping



Allow subscript operator to access element

Allow built-in semantic uses

Use native arrays and proxy arrays interchangably

Array Requirements

arrInt[ 42 ] += 5;

foreach( int i in arrInt ) sum += i;

int[] arrNative = new int[ 5 ];result = MyProxyClass.sumItUp( arrNative );



Cannot extend System.Array, so fully functional .NET arrays are not possible

Proxy array type declares index operator for 90% of desired functionality

Conversion operators provide ability to use .NET array types interchangeably

Array Mapping



No exception specification clause in .NET method declarations!

Need to extend System.Exception or subclass

Cannot extend java.lang.Object proxy class!

May need special serialization support

Exceptions



Java fields map extremely well to .NET properties

Care needs to be taken with static interface fields (Impl classes)

final fields translate to read-only properties

Fields



Fields

Java .NET

interface Context{ public static final String PROVIDER_URL = “…”;}

interface Context{}

public class ContextImpl : Context{ public static string PROVIDER_URL { get { return …; } }}



Anatomy of a Field Access

f.x = 5;

.NET Application Code

public int x {

set { fx.set( value ); }}

.NET Generated Code

PInvokeHelper.set( fx, value );

.NET Runtime Assembly

JNIHelper.set( obj, value );

C Runtime DLL

env->SetIntField( obj, fid, value );

C JVM



because we’re dealing with managed code, we can directly map all constructors

no throws clause

Special cases for methods like toString(), equals(Object), etc.

Methods and Constructors



All non-static Java methods are implicitly virtual

.NET methods can choose virtual is explicit, optional keyword

Which virtual resolution mechanism should we use?

Virtual Methods


Specification Incompatibilities

Corresponding methods of same name but different specification

Corresponding methods with different names but identical specification

CLS Type restrictions

Naming rules (CLS generally more restrictive than JLS)

Different APIs, same purpose (Iterator vs. IEnumerable etc.)


Naming Policy

Offer alternatives:

Keep Java names or

Uppercase first character or

Prefix I for interface names

What’s the right way to name .NET proxies for Java types?

Very important for usability


Naming Policy

Take care with CLS constraints!

No identifiers that only differ in case at same scope

No elements of same name but different element type (method and field of same name, class and method of same name)

Don’t break contracts when changing names!


PInvoke

A way to call unmanaged code from managed code

Managed Code (in assembly)

class MyInvoker{ [DllImport(“myunmanaged.dll”)] public static extern int callMe( int val );}

Unmanaged Code (in myunmanaged.dll)

extern “C” __declspec(dllexport) int __stdcall callMe( int val );


Using JNI (Example)

jclass cl = env->FindClass( “com.codemesh.MyClass” );

if( cl == 0 ) { jthrowable t = env->ExceptionOccurred(); env->ExceptionClear(); return;}

jmethodID mid = env->GetMethodID( cl, “<init>”,“(Ljava/lang/String;IIZ)V” );

if( mid == 0 ) { jthrowable t = env->ExceptionOccurred(); env->ExceptionClear(); env->DeleteLocalRef( cl ); return;}

jstring arg1 = env->NewStringUTF( “test” );


Using JNI (Example) cont.

jobject temp = 0, result = 0;

temp = env->NewObject( cl, mid, arg1, 1, 2, JNI_TRUE );

if( temp == 0 ) { jthrowable t = env->ExceptionOccurred(); env->ExceptionClear(); env->DeleteLocalRef( cl ); return;}

result = env->NewGlobalRef( temp );env->DeleteLocalRef( temp );


Demonstration

A look at the demo source code

A look at particular features of the

enabling source code

A look at a code generator

A Jini example:

hello in C#

Q & A


Literature/References

The Java Native Interface, Programmer’s Guide and Specificationby Sheng Liang, Addison-Wesley, ISBN 0-201-32577-2

Essential JNIby Rob Gordon, Prentice Hall, ISBN 0-136-79895-0

.NET and COM, The Complete Interoperability Guide by Adam Nathan, SAMS, ISBN 0-672-32170-X

JNI Documentationhttp://java.sun.com/products/jdk/1.2/docs/guide/jni/

JGuruhttp://www.jguru.com

Stu Halloway’s Java Interop sitehttp://staff.develop.com/halloway


Thank you!

Codemesh, Inc.P.O.Box 620Carlisle, MA 01741

http://[email protected]

I’ll be aroundfor more questions!

Documents

Copyright 2004 by Codemesh, Inc. All Rights Reserved Welcome Jini in a.NET Environment by Alexander Krapf Jini Community Meeting Cambridge March 23-35,