Problems with .NET 4.5 XmlSerializer, xsi:nillable attribute, and string values

Question

O Great Ones of StackOverflow, hear my plea:

I'm writing .NET 4.5 library code to talk to Oracle SalesCloud services, and I'm having problems with the SOAP requests that have null string values on the C# object.

The XSD for the attributes are specified as follows:

Using the "Add Service Reference..." utility in VS2013 and writing a request where I'm updating something other than OneOfTheStringProperties, the output is


A targeted tutorial to create an extension (or an existing VS2013 extension) that will allow me to right-click on a string property and insert the the following pattern:

[System.Xml.Serialization.XmlIgnoreAttribute()]
public bool [$StringProperty]Specified 
{
    get { return !String.isNullOrEmpty([$StringProperty]); }
    set { }
}



I'm also open to any other suggestions.  If it's a matter of just using the proper search terms (which, apparently, I'm not), that would be greatly appreciated, too.

In furtherance of this request, O Keepers of the Knowledge, I offer this sacrificial goat.

Added For Clarification

Just to make sure, I'm not looking for a one-click magic bullet.  As a developer, and especially one who works on a team where the underlying structure often changes due to requirements, I know that it takes a lot of work to keep things up.

What I am looking for, though, is a reasonable reduction in the workload every time I have to do a refresh on the structure (and for others, a simplified recipe to achieve the same thing.)  For example, using the *Specified means typing in approximately 165+ characters for the given example.  For a contract with 45 string fields, that means I would have to type over 7,425 characters each and every time the model changes--and that's for one service object!  There are about 10-20 service objects up for grabs.

The right-click idea would reduce it down to 45 right-click-click operations...better.

A custom attribute put on the class would be even better, as it only would have to be done once per refresh.

Ideally, a runtime setting in app.config would be a one-and-done--doesn't matter how hard it is to implement the first time, since that goes into the library. 

I think the true answer is somewhere better than almost 7500 characters/class and probably not as good as a simple app.config setting, but it's either out there or I believe it can be made.

a-h · Accepted Answer

Here's how to add a custom behaviour to the WCF client which can be used to inspect the message and skip the properties.

This is a combination of:

Full Code:

void Main()
{
    var endpoint = new Uri("http://somewhere/");

    var behaviours = new List()
    {
        new SkipConfiguredPropertiesBehaviour(),
    };

    var channel = Create(endpoint, GetBinding(endpoint), behaviours);
    channel.SendData(new Data()
    {
        SendThis = "This should appear in the HTTP request.",
        DoNotSendThis = "This should not appear in the HTTP request.",
    });
}

[ServiceContract]
public interface IRemoteService
{
    [OperationContract]
    int SendData(Data d);
}

public class Data
{
    public string SendThis { get; set; }
    public string DoNotSendThis { get; set; }
}

public class SkipConfiguredPropertiesBehaviour : IEndpointBehavior
{
   public void AddBindingParameters(
        ServiceEndpoint endpoint,
        BindingParameterCollection bindingParameters)
    {
    }

    public void ApplyClientBehavior(
        ServiceEndpoint endpoint, 
        ClientRuntime clientRuntime)
    {
        clientRuntime.MessageInspectors.Add(new SkipConfiguredPropertiesInspector());
    }

    public void ApplyDispatchBehavior(
        ServiceEndpoint endpoint, 
        EndpointDispatcher endpointDispatcher)
    {
    }

    public void Validate(
        ServiceEndpoint endpoint)
    {
    }
}

public class SkipConfiguredPropertiesInspector : IClientMessageInspector
{
    public void AfterReceiveReply(
        ref Message reply, 
        object correlationState)
    {
        Console.WriteLine("Received the following reply: '{0}'", reply.ToString());
    }

    public object BeforeSendRequest(
        ref Message request, 
        IClientChannel channel)
    {     
        Console.WriteLine("Was going to send the following request: '{0}'", request.ToString());

        request = TransformMessage(request);

        return null;
    }

    private Message TransformMessage(Message oldMessage)
    {
        Message newMessage = null;
        MessageBuffer msgbuf = oldMessage.CreateBufferedCopy(int.MaxValue);
        XPathNavigator nav = msgbuf.CreateNavigator();

        //load the old message into xmldocument
        var ms = new MemoryStream();
        using(var xw = XmlWriter.Create(ms))
        {
            nav.WriteSubtree(xw);
            xw.Flush();
            xw.Close();
        }

        ms.Position = 0;
        XDocument xdoc = XDocument.Load(XmlReader.Create(ms));

        //perform transformation
        var elementsToRemove = xdoc.Descendants().Where(d => d.Name.LocalName.Equals("DoNotSendThis")).ToArray();

        foreach(var e in elementsToRemove)
        {
            e.Remove();
        }

        // have a cheeky read...
        StreamReader sr = new StreamReader(ms);
        Console.WriteLine("We're really going to write out: " + xdoc.ToString());

        //create the new message           
        newMessage = Message.CreateMessage(xdoc.CreateReader(), int.MaxValue, oldMessage.Version);

        return newMessage;
    }    
}

 public static T Create(Uri endpoint, Binding binding, List behaviors = null)
{
    var factory = new ChannelFactory(binding);

    if (behaviors != null)
    {
        behaviors.ForEach(factory.Endpoint.Behaviors.Add);
    }

    return factory.CreateChannel(new EndpointAddress(endpoint));
}

public static BasicHttpBinding GetBinding(Uri uri)
{
    var binding = new BasicHttpBinding()
    {
        MaxBufferPoolSize = 524288000, // 10MB
        MaxReceivedMessageSize = 524288000,
        MaxBufferSize = 524288000,
        MessageEncoding = WSMessageEncoding.Text,
        TransferMode = TransferMode.Buffered,
        Security = new BasicHttpSecurity()
        {
            Mode = uri.Scheme == "http" ? BasicHttpSecurityMode.None : BasicHttpSecurityMode.Transport,
        }
    };

    return binding;
}

Here's a link to the LinqPad script: http://share.linqpad.net/kgg8st.linq

If you run it, the output will be something like:

Was going to send the following request: '
  
    http://tempuri.org/IRemoteService/SendData
  
  
    
      
        This should not appear in the HTTP request.
        This should appear in the HTTP request.
      
    
  
'
We're really going to write out: 
  
    http://tempuri.org/IRemoteService/SendData
  
  
    
      
        This should appear in the HTTP request.

Problems with .NET 4.5 XmlSerializer, xsi:nillable attribute, and string values

Answers (2)

Related Questions