[Apache Web Services Wiki] New: DotNetInteropArrays

[ge...@ws.apache.org]

   Date: 2005-03-15T08:48:03
   Editor: DinoChiesa
   Wiki: Apache Web Services Wiki
   Page: DotNetInteropArrays
   URL: http://wiki.apache.org/ws/DotNetInteropArrays

   first edit.

New Page:

##language:en


AXIS and .NET can exchange Arrays.  Arrays of primitives, or Arrays of complex types. 

First thing to do is stay away from {{{SOAPENC:arrayType}}} since we all listen to WS-I. We'll doc/literal encoding. Agreed?
 
Ok, then Within the WSDL, in the <types> section, specify a type or element that wraps an array, using an element with maxOccurs != 1, like so:  

{{{
 <s:complexType name="Container">
   <s:sequence>
     <s:element minOccurs="1" maxOccurs="1" name="param1" nillable="true" type="s:string" /> 
     <s:element minOccurs="0" maxOccurs="unbounded" name="param2" type="s:string" /> 
   </s:sequence>
  </s:complexType>
}}}

The param2 above can be of any type (simple or complex or XSD primitive).  

Then, use WSDL2''''''Java to generate the Java classes for this.  The generated Java code will look like the following: 

{{{
 class Container{
       String param1;
       String[] param2;
        
       public String getParam2(index i) {
           return param2[i];
       }
       public void setParam2(index i, String value) {
           param2[i] = value;
       }
       public String[] getParam2() {
           return param2;
       }
       public void setParam2(String[] value) {
           param2 = value;
       }
   }
}}}

The XML on the wire will be: 

{{{ 
  <Container> 
    <param1> foo</param1> 
    <param2>bar</param2> 
    <param2>blah</param2> 
        ... 
   </Container> 
}}}

And the .NET client will be completely happy with that.  

On the other hand if you structure your WSDL to use a wrapper type (Array''''''Of''''''Xxx) for the array, like so: 

{{{
 
  <s:complexType name="Container">
     <s:sequence>
       <s:element minOccurs="1" maxOccurs="1" name="param1" nillable="true" type="s:string" />
       <s:element minOccurs="1" maxOccurs="1" name="wrapper" nillable="true" type="tns:ArrayOfString" />
     </s:sequence>
   </s:complexType>
   <s:complexType name="ArrayOfString">
     <s:sequence>
       <s:element minOccurs="0" maxOccurs="unbounded" name="param2" type="s:string" />
     </s:sequence>
   </s:complexType>
 
}}}

(the Array''''''Of''''''Xxx name is actually not significant, just the structure is important.) 
... then the generated Java code will look like: 
{{{
   class Container {
       String param1;
       ArrayOfString wrapper;
   }

  class ArrayOfString{
      String[] param2;
  }
}}}


... and the XML on the wire will be like this:
{{{
  <Container> 
    <param1> foo</param1> 
    <wrapper> 
        <param2>bar</param2> 
        <param2>blah</param2> 
        ... 
    </wrapper>  
   </Container> 
}}}


and .NET will be happy with that also.  

Using the wrapper type specified in the WSDL, the programming model in the generated Java/AXIS code explicitly exposes the Array''''''Of''''''Xxx type.  On the other hand, with .NET, the programming model is the same: both styles of WSDL will generate simple arrays like My''''''Type[].  What varies on the .NET side is the metadata attached to the artifacts in the form of inline attributes.  
  
.NET can go either way.  It takes its cue from the WSDL.  
  
So you can do whatever. 

At one point, there was a bug in AXIS dealing with an operation that returns an array
directly, rather than a structure containing an array  (ie, an operation
like {{{String[] getInfo()}}} rather than {{{ Container getInfo()}}}).  This may still be present in AXIS V1.2RC3.  Dims?