Building a SOAP Client with C#: Sending and Receiving Requests

Welcome to this comprehensive guide on creating a client in C# that can send and receive Simple Object Access Protocol (SOAP) requests. This tutorial assumes no prior exposure to the topic, providing you with all necessary information to understand and implement SOAP communication in your applications.

Introduction to SOAP

SOAP is a protocol used for exchanging structured information in web services implementation. It relies on XML for its message format and usually operates over HTTP or SMTP. SOAP can be seen as a way to build distributed computing systems across platforms and programming languages, making it a versatile choice for service-oriented architectures (SOA).

What You’ll Build

We will develop a C# application that sends a SOAP request to a web service and processes the response. This client could be part of a Windows service or any standalone .NET application.

Setting Up Your Environment

Before we begin, make sure you have the following:

• A development environment capable of running C# code (such as Visual Studio).
• Access to a SOAP web service endpoint for testing purposes.
• Basic understanding of C#, XML, and HTTP communications.

Understanding the Process

The process involves creating an XML envelope that adheres to the SOAP standard, crafting an HTTP request with this envelope as its body, sending the request over the network to a server providing a SOAP-based web service, and finally processing the response received from the server.

Creating the SOAP Envelope

A SOAP message is encapsulated within an XML document called the SOAP envelope. This envelope consists of two main parts: the header (optional) and the body. The body contains the call or response information, including method names and parameters if it’s a request.

Here’s how you can create a simple SOAP envelope in C#:

private static XmlDocument CreateSoapEnvelope()
{
    XmlDocument soapEnvelope = new XmlDocument();
    soapEnvelope.LoadXml(
        @"<?xml version=""1.0"" encoding=""utf-8""?>
          <soap:Envelope xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
            xmlns:xsd=""http://www.w3.org/2001/XMLSchema""
            xmlns:soap=""http://schemas.xmlsoap.org/soap/envelope/"">
            <soap:Body>
                <HelloWorld xmlns=""http://tempuri.org/"">
                    <int1 xsi:type=""xsd:int"">12</int1>
                    <int2 xsi:type=""xsd:int"">32</int2>
                </HelloWorld>
            </soap:Body>
        </soap:Envelope>");
    return soapEnvelope;
}

In this example, we have defined a SOAP envelope that includes a method HelloWorld with two integer parameters.

Crafting the HTTP Request

With our SOAP envelope ready, we must construct an HTTP request to carry it. This is done using the HttpWebRequest class in C#. We need to set various headers and properties of this object to ensure the server interprets our message correctly as a SOAP request.

Here’s a snippet that demonstrates creating a web request for sending a SOAP message:

private static HttpWebRequest CreateWebRequest(string url, string action)
{
    var webRequest = (HttpWebRequest)WebRequest.Create(url);
    webRequest.Headers.Add("SOAPAction", action);
    webRequest.ContentType = "text/xml;charset=\"utf-8\"";
    webRequest.Accept = "text/xml";
    webRequest.Method = "POST";

    return webRequest;
}

In this method, we’re configuring our request with a SOAPAction header, which is vital for informing the server about the intended action of the SOAP message. We also set the ContentType to indicate that we’re sending XML data.

Sending and Receiving the Request

Once the web request is properly prepared with its headers, content type, and method set, we must send it and handle the response. This step involves writing our SOAP envelope into the request stream, making an asynchronous call, and reading back the server’s reply.

public static void SendSoapRequest()
{
    string url = "http://www.example.com/Service.asmx";
    string soapAction = "http://tempuri.org/HelloWorld";

    HttpWebRequest webRequest = CreateWebRequest(url, soapAction);
    XmlDocument soapEnvelopeXml = CreateSoapEnvelope();

    using (Stream stream = webRequest.GetRequestStream())
    {
        soapEnvelopeXml.Save(stream);
    }

    IAsyncResult asyncResult = webRequest.BeginGetResponse(null, null);

    // Here we wait for the response to complete
    asyncResult.AsyncWaitHandle.WaitOne();
    
    string result;
    using (WebResponse response = webRequest.EndGetResponse(asyncResult))
    {
        using (StreamReader reader = new StreamReader(response.GetResponseStream()))
        {
            result = reader.ReadToEnd();
        }
        Console.WriteLine(result);
    }
}

The SendSoapRequest method encapsulates the process of sending a SOAP message and receiving the server’s response. It showcases how to write the XML data into the request stream, initiate an asynchronous HTTP call, wait for completion, and finally read the response.

Conclusion

SOAP is a protocol that offers robust capabilities for web service communication. In this tutorial, we’ve explored how to implement a basic SOAP client in C#. While modern applications often favor RESTful services due to their simplicity and flexibility, understanding SOAP is crucial when dealing with legacy systems or enterprise-level integrations where SOAP is still the standard.

Remember, this guide serves as an introduction; further exploration into error handling, asynchronous programming patterns, and security measures (such as HTTPS and WS-Security) will be necessary for production-ready applications.