Welcome

1. Welcome Jini Community Meeting Cambridge March 23-35, 2004 Jini in a .NET Environment by Alexander Krapf

2. 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

3. 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

4. Jini and .NET Why would I want to do that ?

5. 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

6. Jini and .NET ... Why? • 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

7. Jini and .NET ... Why? • Because not everyone develops software in Java • Because I would hate to see distributed computing dominated by J2EE and Web Services

8. What does an integration look like? Example 1: JavaSpaces JavaSpace VB.NET Client Java Servers C# Client Java Client

9. What does an integration look like? Example 2: Service Oriented Architecture C# Client Jini Service Java Client VB Client Not a very exciting slide, but an exciting design!

10. Jini and .NET OK, I buy the occasional need, but what exactlydoes “Jini and .NET” mean?

11. Definition of Java What is the Java platform?

12. Definition of .NET What is the .NET platform? CLR CLR: Common Language Runtime CIL: Common Intermediate Language CTS: Common Type System CLS: Common Language Specification C#LanguageSpec HostSpec VB.NETLanguageSpec CTS CIL CLS mC++LanguageSpec

13. What we really want Define the goals • Write C#, VB, C++, etc. source code that “links with” arbitrary Jini code easily • Write C#, VB, C++, etc. source code that allows natural use of all native features • Use all important Jini features from .NET, including callbacks • Impose no prohibitive performance penalty

14. What we really want (cont.) Write C# code like this: [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” ); … }

15. What we really want (cont.) Lots of Problems in a short snippet! [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” ); … }

16. Jini and .NET The Jini twist on theJava/.NET integrationproblem…

17. Application #2 Application #1 Why it is a hard problem… Jini leverages Java! Application JINI RMI/code mobility Security/Classloaders Platformindependence

18. Integrating Jini with .NET ... How? Technical Requirements • Must accommodate downloaded code • Must support RMI • Must support Java and Jini security • Must support callbacks

19. Integrating Jini with .NET ... How? Architectural Alternatives • Serialization/Message-based: CORBA, Webservices, MOM, custom • Translation-based: Java to C#, Bytecode to IL • Proxy-based: Java Native Interface managed C++ or PInvoke

20. Serialization/Message-Based • CORBA • WebServices • MOM • Custom - database - filesystem - sockets

21. Serialization/Message-Based • Different technologies, same principles - object/service discovery through naming service, UDDI, custom registries - argument/result serialization through IIOP, SOAP, XML, ... - several processes or “objects” involved Java process, .NET process, file locks, table rows, helpers

22. Translation-Based Integration Promising at first, but very problematic • Large set of classes involved • transitive 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 • “Stale bits” are uncheckable and out-of-date

23. Proxy-Based Solution Jini Example .NET Client RuntimeLibrary JVM Java Server Proxy’ Proxy Service Proxy’ Proxy Service Client Process Server Process

24. C C# JNI PInvoke API DLL assembly Proxy-Based Solution Architectural Diagram JVM GeneratedProxyClasses(C#) .NETUser

25. Proxy-Based Solution 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

26. Proxy-Based Solution xcopy Deployment <myapp> bin application binaries and config files lib application Java classes (jar,zip) jre private Java runtime environment

27. Proxy-Based Solution 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 ?

28. 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?

29. Type Mapping General Issues • Both platforms have object models • Slightly incompatible specifications • Both platforms have class libraries • Typenames are duplicated • Different Naming Policies

30. Object Model Mapping Overall a good match • class to class • interface to interface • constructor to constructor • method to method • field to property

31. Object Model Mapping But there are problems • conflicting Array models • conflicting Exception models • cannot declare static members for interfaces (CLS) • CLS has more restrictive naming than Java

32. Object Model Mapping Object Lifecycle • both sides use garbage collection • JNI references need to be freed explicitly • IDisposable together with finalization offer what we need • Care required with callbacks!

33. Object Model Mapping ClassesJava .NET Object Object String Throwable String Exception Error Exception SystemException ApplicationException RuntimeException

34. Object Custom Type Throwable Custom Type Custom Type Error Exception CustomException CustomException Neither Strings nor Throwablesare Java Objects anymore! CustomException RuntimeException Type System Mapping .NET with mapped Java Types Object String String Exception SystemException ApplicationException

35. Object Model Mapping Object Requirements • Java proxy types should extend proxy Object type (with exceptions) • Every proxy type must be usable in all places where Java Object is legal

36. Object Model Mapping String 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 getProperty( String name ) Object put( Object key, Object value )

37. Object Model Mapping String Mapping • java.lang.String must map toSystem.String because of literals • Large impact on Object-type elements Object put( Object key, Object value ) becomes object put( object key, object value )

38. Object Model Mapping Interface Requirements • 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)

39. Object Model Mapping Interface Mapping • 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?

40. Object Model Mapping Array Requirements • Allow subscript operator to access element • Allow built-in semantic uses • Use native arrays and proxy arrays interchangably arrInt[ 42 ] += 5; foreach( int i in arrInt ) sum += i; int[] arrNative = new int[ 5 ];result = MyProxyClass.sumItUp( arrNative );

41. Object Model Mapping Array Mapping • 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

42. Object Model Mapping Exceptions • 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

43. Object Model Mapping Fields • 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

44. Object Model Mapping Fields Java .NET interface Context { } public class ContextImpl : Context { public static string PROVIDER_URL { get { return …; } } } interface Context { public static final String PROVIDER_URL = “…”; }

45. C JVM .NET Generated Code env->SetIntField( obj, fid, value ); public int x { set { fx.set( value ); } } C Runtime DLL JNIHelper.set( obj, value ); .NET Runtime Assembly PInvokeHelper.set( fx, value ); Object Model Mapping Anatomy of a Field Access .NET Application Code f.x = 5;

46. Object Model Mapping Methods and Constructors • 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.

47. Object Model Mapping Virtual Methods • All non-static Java methods are implicitly virtual • .NET methods can choosevirtual is explicit, optional keyword Which virtual resolution mechanism should we use?

48. 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.)

49. Naming Policy What’s the right way to name .NET proxies for Java types? • Very important for usability Offer alternatives: • Keep Java names or • Uppercase first character or • Prefix I for interface names

50. 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!