Question

We have custom XML serialization for our “protocol” here:

[XmlRoot("axf", Namespace = Axf10Namespace)]
public class AxfDocument : IXmlSerializable
{
  public const string Axf10Namespace = "http://schemas.***.ru/axf/axf-1.0.0";
  // ...
}

and all’s fine when using standard .NET XmlSerializer:

<?xml version="1.0" encoding="utf-16"?>
<axf version="1.0.0" createdAt="2011-10-20T13:11:40" xmlns="http://schemas.***.ru/axf/axf-1.0.0">
  <itineraries>
    <!-- -->
   </itineraries>
</axf>

Now that we try to use this class in a bare-bones WCF service:

[OperationContract]
AxfDocument GetItineraries(ItinerariesQuery query);

actual XML document that gets sent to client side is this:

<GetItinerariesResult version="1.0.0" createdAt="2011-10-20T13:17:50" xmlns="http://tempuri.org/">
  <itineraries xmlns="http://schemas.***.ru/axf/axf-1.0.0">
    <!-- rest is fine, serialization code does work -->

How do I bend WCF to send root element as-is and not to replace it with its own?

Answer 1

By default, the operation responses are wrapped in the operation name. You can, however, use a MessageContract in the operation definition to use an “unwrapped” response, as shown below. If you look at the response body of the request in Fiddler, you’ll see that it’s exactly as the one from the serialization.

public class StackOverflow_7836645
{
    [XmlRoot("axf", Namespace = Axf10Namespace)]
    public class AxfDocument : IXmlSerializable
    {
        public const string Axf10Namespace = "http://schemas.something.ru/axf/axf-1.0.0";

        public XmlSchema GetSchema()
        {
            return null;
        }

        public void ReadXml(XmlReader reader)
        {
        }

        public void WriteXml(XmlWriter writer)
        {
            writer.WriteStartElement("intineraries", Axf10Namespace);
            writer.WriteElementString("item", Axf10Namespace, "one value");
            writer.WriteElementString("item", Axf10Namespace, "another value");
            writer.WriteEndElement();
        }
    }

    [MessageContract(IsWrapped = false)]
    public class OperationResponse
    {
        [MessageBodyMember(Name = "axf", Namespace = AxfDocument.Axf10Namespace)]
        public AxfDocument axf;
    }

    [ServiceContract]
    public interface ITest
    {
        [OperationContract]
        OperationResponse GetAxf();
    }

    public class Service : ITest
    {
        public OperationResponse GetAxf()
        {
            return new OperationResponse { axf = new AxfDocument() };
        }
    }

    public static void Test()
    {
        Console.WriteLine("Serialization");
        MemoryStream ms = new MemoryStream();
        XmlSerializer xs = new XmlSerializer(typeof(AxfDocument));
        xs.Serialize(ms, new AxfDocument());
        Console.WriteLine(Encoding.UTF8.GetString(ms.ToArray()));

        Console.WriteLine();
        Console.WriteLine("Service");

        string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
        ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress));
        host.AddServiceEndpoint(typeof(ITest), new BasicHttpBinding(), "");
        host.Open();
        Console.WriteLine("Host opened");

        ChannelFactory<ITest> factory = new ChannelFactory<ITest>(new BasicHttpBinding(), new EndpointAddress(baseAddress));
        ITest proxy = factory.CreateChannel();
        Console.WriteLine(proxy.GetAxf());

        ((IClientChannel)proxy).Close();
        factory.Close();

        Console.Write("Press ENTER to close the host");
        Console.ReadLine();
        host.Close();
    }
}