Question

I’m consuming a webservice from another company, they have multiple versions running, each newer version has only added new fields/objects, BUT changes some of the element names.

I would like the ability to consume any of the versions with the same code.

Specifically In one version a search method returns:
<searchReturn><SummaryData_Version1Impl /><SummaryData_Version1Impl /></searchReturn>

and in a different version: <searchReturn><SummaryData_Version2Impl /><SummaryData_Version2Impl /></searchReturn>

So right now the proxy generated by wsdl.exe cannot work with both because of that element change.

1. The best solution would be to make the other company fix their service to not change the element names, but that is fairly unlikely in this situation
2. I’m thinking my best bet for a working solution is to send and get the SOAP request manually, and modify the element names then deserialize manually which so far has seemed like it would work. — But would require quite a bit of work
   • I just confirmed that manually loading the xml (after changing the element name with string.Replace) will deserialize any version of the service into the needed objects
3. Alternatively do a similar thing by modifying the generated proxy:
   • If i could intercept and modify the soap response before the generated proxy tries to deserialize it
   • If I could modify the XmlTypeAttribute of the service at runtime
4. I’ve also thought of having a series of interfaces, so each class would have the interfaces of the older class Data3 : IData3, IData2, IData1 Which I’m thinking would allow me to at least cast downward. And put each version into a different namespace.
5. There is a couple duck typing techniques I have just looked into slightly which might be able to work, but seems less reliable.
6. Is there any other way to deserialize from multiple element names?

Answer 1

I now think the best option is to use a SoapExtension and set a SoapExtensionAttribute to trigger using that on any methods you need to modify the response for.

1. Modify the generated code and add the attribute [ModifyResponseExtensionAttribute] to any methods that require the modifications, in your case you might need multiple SoapExtension classes

2. Add the following classes to your project:

   public class ModifyResponseExtension : SoapExtension
   {
       Stream inStream;
       Stream outStream;
   
       // Save the Stream representing the SOAP request or SOAP response into
       // a local memory buffer.
       public override Stream ChainStream(Stream stream)
       {
           inStream = stream;
           outStream = new MemoryStream();
           return outStream;
       }
   
       //This can get properties out of the Attribute used to enable this
       public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
       {
           return null;
       }
   
       //This would have default settings when enabled by config file
       public override object GetInitializer(Type WebServiceType)
       {
           return null;
       }
   
       // Receive the object returned by GetInitializer-- set any options here
       public override void Initialize(object initializer)
       {
       }
   
       //  If the SoapMessageStage is such that the SoapRequest or
       //  SoapResponse is still in the SOAP format to be sent or received,
       //  save it out to a file.
       public override void ProcessMessage(SoapMessage message)
       {
           switch (message.Stage)
           {
               case SoapMessageStage.BeforeSerialize:
                   break;
               case SoapMessageStage.AfterSerialize:
                   //This is after the Request has been serialized, I don't need to modify this so just copy the stream as-is
                   outStream.Position = 0;
                   Copy(outStream, inStream);
                   //Not sure if this is needed (MSDN does not have it) but I like closing things
                   outStream.Close();
                   inStream.Close();
                   break;
               case SoapMessageStage.BeforeDeserialize:
                   //This is before the Response has been deserialized, modify here
                   //Could also modify based on something in the SoapMessage object if needed
                   ModifyResponseMessage();
                   break;
               case SoapMessageStage.AfterDeserialize:
                   break;
           }
       }
   
       private void ModifyResponseMessage()
       {
           TextReader reader = new StreamReader(inStream);
           TextWriter writer = new StreamWriter(outStream);
   
           //Using a StringBuilder for the replacements here
           StringBuilder sb = new StringBuilder(reader.ReadToEnd());
   
           //Modify the stream so it will deserialize with the current version (downgrading to Version1_1 here)
           sb.Replace("SummaryData_Version2_2Impl", "SummaryData_Version1_1Impl")
               .Replace("SummaryData_Version3_3Impl", "SummaryData_Version1_1Impl")
               .Replace("SummaryData_Version4_4Impl", "SummaryData_Version1_1Impl");
           //Replace the namespace
           sb.Replace("http://version2_2", "http://version1_1")
               .Replace("http://version3_3", "http://version1_1")
               .Replace("http://version4_4", "http://version1_1");
   
           //Note: Can output to a log message here if needed, with sb.ToString() to check what is different between the version responses
   
           writer.WriteLine(sb.ToString());
           writer.Flush();
   
           //Not sure if this is needed (MSDN does not have it) but I like closing things
           inStream.Close();
   
           outStream.Position = 0;
       }
   
       void Copy(Stream from, Stream to)
       {
           TextReader reader = new StreamReader(from);
           TextWriter writer = new StreamWriter(to);
           writer.WriteLine(reader.ReadToEnd());
           writer.Flush();
       }
   }
   
   // Create a SoapExtensionAttribute for the SOAP Extension that can be
   // applied to an XML Web service method.
   [AttributeUsage(AttributeTargets.Method)]
   public class ModifyResponseExtensionAttribute : SoapExtensionAttribute
   {
       private int priority;
   
       public override Type ExtensionType
       {
           get { return typeof(ModifyResponseExtension); }
       }
   
       public override int Priority
       {
           get { return priority; }
           set { priority = value; }
       }
   }
   

So it is very possible to manually modify the request/responses of the wsdl.exe generated class when needed.