WCF endpoint: Message.WriteMessage changes the closing tags inside the XML message

Question

I am using a custom endpoint behavior extension to intercept messages as they are received by my WCF service endpoint, using IDispatchMessageInspector. I retrieve the message content like this:

public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
    MessageBuffer messageBuffer = request.CreateBufferedCopy(Int32.MaxValue);
    Message message = messageBuffer.CreateMessage();

    using (MemoryStream stream = new MemoryStream())
    {
        using (XmlWriter writer = XmlWriter.Create(stream))
        {
            message.WriteMessage(writer);
            writer.Flush();
            stream.Position = 0;
        }
    }
}

I need to obtain the XML message exactly as it is sent by the client, but the XML that is written to the stream seems to be modified by WCF (or the XmlWriter?). My main problem is that it has modified closing tags: <id /> becomes <id></id> everywhere in the XML message. Is there a way to write the message content as it was received by the endpoint without it being modified (or at least without changing the way the tags are closed?

Answer 1

I have not tested this, but it might be worth a try.

Idea is that the modification to the xml is being done by the xmlwriter.

You could then get the contents of the message by doing a message.ToString().

EDIT Looks like WCF will change the XML on the server or client side if you send it over as xml.

What you could do is to send the xml over as a byte array, that way WCF will not try to change it.

EDIT 2 The custom message encoder that you mentioned, looks like it both encodes and decodes messages. Would it therefore need to run on the client side as well?

Answer 2

Ok I solved my problem. It was not Message.WriteMessage that was modifiying the XML closing tags, but MessageBuffer.CreateBufferedCopy! It turns out I no longer need to copy the message before I write it, so not calling CreateBufferedCopy before Message.WriteMessage produces the XML with the closing tags unmodified.

Note however that the written XML might still not be exactly as it was received from the client, WCF stills changes some things like carriage returns, etc. I also experimented with custom WCF MessageEncoders like I mentionned in the comments. It gives you complete control over how WCF creates the Message object from the bytes received on the wire.

So if you need to prevent WCF from modifying things in the data that was received or you need to access the raw bytes of the request, you can use custom MessageEncoders. See this sample from Microsoft:

Custom Message Encoder Sample

Thanks for your help!