Return WCF SOAP Response from ASP Web API

3 min read 06-10-2024

Return WCF SOAP Response from ASP Web API

Returning WCF SOAP Responses from ASP.NET Web API: Bridging the Gap

Problem: You're working on a project with existing WCF services, but you need to expose some functionality through a modern ASP.NET Web API. You're struggling with how to return the familiar SOAP response format from your Web API endpoints.

Solution: This article explains how to return WCF SOAP responses from ASP.NET Web API, bridging the gap between legacy systems and newer technologies.

The Scenario

Imagine you have a WCF service with a method defined like this:

[ServiceContract]
public interface IMyService
{
    [OperationContract]
    string GetData(string input);
}

And a corresponding implementation:

public class MyService : IMyService
{
    public string GetData(string input)
    {
        return "Data from WCF service: " + input;
    }
}

This service returns a simple string response, but you need to access it through an ASP.NET Web API endpoint.

The Challenge

The traditional ASP.NET Web API approach focuses on RESTful APIs, returning JSON or XML data. However, you need to retain the SOAP format for compatibility with clients expecting that specific structure.

Bridging the Gap with a Custom Serializer

The key is to create a custom serializer that handles the SOAP response format. Here's how you can achieve this:

Create a custom MessageFormatter: This custom formatter will handle the serialization of your response into SOAP.

using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.Xml;

public class SoapMessageFormatter : MessageFormatter
{
    public SoapMessageFormatter(MessageVersion messageVersion) : base(messageVersion)
    {
    }

    public override bool IsRequest { get { return false; } }

    public override MessageVersion MessageVersion { get { return MessageVersion.Soap11; } }

    public override Message ReadRequest(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
    {
        throw new NotImplementedException();
    }

    public override Message ReadResponse(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
    {
        throw new NotImplementedException();
    }

    public override void WriteRequest(Message message, ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
    {
        throw new NotImplementedException();
    }

    public override void WriteResponse(Message message, ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
    {
        // Serialize the response into a SOAP message.
        var xmlWriter = XmlWriter.Create(new MemoryStream(), new XmlWriterSettings { Indent = true });
        message.WriteMessage(xmlWriter);
        var responseBytes = ((MemoryStream)xmlWriter.BaseStream).ToArray();

        // Copy the response bytes to the buffer.
        Array.Copy(responseBytes, 0, buffer.Array, buffer.Offset, responseBytes.Length);
    }
}

Implement the MessageFormatter to handle SOAP serialization:
- WriteResponse method: This method takes a Message object and writes the response into a SOAP message using XmlWriter.
- ReadRequest and ReadResponse: These methods are not used in this scenario as we are only concerned with writing a SOAP response.

Configure the Web API endpoint to use the custom formatter:

public class MyApiController : ApiController
{
    [HttpGet]
    public HttpResponseMessage GetData(string input)
    {
        // Access your WCF service or logic
        var data = // Call WCF service method or other logic
        var responseMessage = new HttpResponseMessage();

        // Create the response message with SOAP content
        responseMessage.Content = new StringContent(data, Encoding.UTF8, "application/soap+xml"); 

        // Set the custom formatter
        responseMessage.Content.Headers.ContentType.MediaType = "application/soap+xml; charset=utf-8";
        responseMessage.Content.Headers.ContentType.CharSet = "utf-8";
        responseMessage.Content.Headers.ContentType.MediaTypeParameters.Add(new NameValueHeaderValue("charset", "utf-8"));

        // Customize the response message headers
        responseMessage.Headers.Add("SOAPAction", "your-soap-action"); 

        return responseMessage;
    }
}

Explanation

The code above demonstrates how to:

Create a custom MessageFormatter: This formatter specifically handles SOAP response serialization.
Use the MessageFormatter: You can create an instance of the SoapMessageFormatter and set it as the MessageFormatter for your HttpResponseMessage.
Customize the HttpResponseMessage: Set the content type to "application/soap+xml" and add the necessary headers for proper SOAP communication.

Benefits

Flexibility: This approach allows you to maintain the SOAP response format while leveraging ASP.NET Web API's functionality.
Compatibility: It ensures seamless communication with existing clients that expect SOAP responses.

Considerations

Performance: Custom serialization might introduce overhead, especially with complex data structures. Consider the performance impact for large payloads.
Maintenance: This approach requires maintaining custom code for serialization, adding complexity to your codebase.

Further Exploration

SOAP Message Inspection: For more sophisticated scenarios, you can use the Message object to inspect and manipulate the SOAP message before sending it.
WCF Client: Consider using a WCF client to directly consume the WCF service within your Web API project. This simplifies communication and avoids custom serialization.

Conclusion

Returning WCF SOAP responses from ASP.NET Web API provides a practical solution for integrating legacy systems with modern web applications. This article guides you through the process of creating a custom serializer and configuring your Web API endpoint for seamless SOAP communication.