How to Create SOAP Web Service Using WSDL in ASP.NET Core (.NET 8)

Introduction

SOAP still powers critical integrations at Salesforce, SAP, Oracle NetSuite, and most banks. REST is faster to build and easier to debug. But when the other end of the wire belongs to a financial institution or enterprise ERP, SOAP’s WSDL contract and WS-Security are often non-negotiable.

This tutorial shows how to build a SOAP service in ASP.NET Core using SoapCore. Code examples target .NET 8 LTS and work unchanged in .NET 9.

The sections below walk through building and consuming a SOAP service step by step.

Creating a SOAP web service WSDL in Visual Studio ASP.NET Core (.NET 8)

1. 1. Launch Visual Studio 2022 on your machine.

      To follow the code examples in this article you need Visual Studio 2022. Download it from the Microsoft website if you do not already have it.

      

   2. Create a New Project.

      Navigate to “File” > “New” > “Project…”

      Choose the appropriate project template, such as “ASP.NET Core WebAPI.”

      

   3. Set up the Project in ASP.NET Core Web API and configure project settings, including the project name and location.

      

   4. Install the SoapCore package.

      After creating your Web API project in Visual Studio, incorporate the SoapCore NuGet package into it. Follow these steps:

      • Navigate to the Solution Explorer window,
      • Choose the project,
      • right-click, and opt for “Manage NuGet Packages”.

      In the NuGet Package Manager window, locate the SoapCore package , then install it.

      You can also get the SoapCore package by using the NuGet Package Manager console. To start installing it you need to type in a command. The command you need to type is the one that starts the installation of the SoapCore package.

   5. Define the Data Contract.

      In the data contract, we define the characteristics of each SoapService data type, such as their types, names, and any rules or restrictions.

      This ensures that clients and services built with different programming languages or platforms can communicate effectively.

      
      namespace SoapService.Models
      {
          public class CustomerDataContract
          {
              [DataContract]
              public class Author
              {
                  [DataMember]
                  public int Id { get; set; }
      
                  [DataMember]
                  public string FirstName { get; set; }
      
                  [DataMember]
                  public string LastName { get; set; }
      
                  [DataMember]
                  public string EmailAddress { get; set; }
              }
          }
      }
      

   6. Define the Service Contract

      A service contract is made up of two parts. The service interface is one part. It tells us what the service does. The other part has details like how messages are formatted and how security works. We use something called the ServiceContract attribute in C# to define all of this. This ServiceContract attribute is like a label that we put on an interface or class to say that it is a service contract. The ServiceContract attribute is important because it marks the interface or class as a service contract, in C#.

      The ServiceContract attribute is really important because it marks the interface or the class as a ServiceContract in C#. This is how we use the ServiceContract attribute to make it clear that something is a ServiceContract. The ServiceContract attribute is what makes this work, in C#.

      
      namespace SoapService.Models
      {
          public class CustomerServiceContract
          {
              [ServiceContract]
              public interface ICustomerService
              {
                  [OperationContract]
                  CustomerDataContract GetCustomers();
              }
          }
      }
        

   7. Create a service and add a method to the service with customer data.

      
      namespace SoapService.Services
      {
          public class CustomerService : ICustomerService
          {
              public CustomerDataContract GetCustomers()
              {
                  return new CustomerDataContract
                  {
                      Id = 1,
                      FirstName = "John",
                      LastName = "Doe",
                      EmailAddress = "john.doe@example.com"
                  };
              }
          }
      }
      

   8. Register a SOAP service in the Program.cs (.NET 8 Format)

      
        builder.Services.AddSingleton<ICustomerService, CustomerService>();
      

   9. Configure the HTTP request pipeline for the SOAP endpoint in Program.cs

      
      app.UseSoapEndpoint<ICustomerService>("/CustomerService.asmx", new SoapEncoderOptions());
      

   10. Complete the source code of the Program.cs

       
       using SoapCore;
       using SoapService.Services;
       using static SoapService.Models.CustomerServiceContract;
       
       var builder = WebApplication.CreateBuilder(args);
       
       // Add services to the container.
       builder.Services.AddSingleton<ICustomerService, CustomerService>();
       builder.Services.AddControllers();
       var app = builder.Build();
       
       // Configure the HTTP request pipeline.
       app.UseSoapEndpoint<ICustomerService>("/CustomerService.asmx", new SoapEncoderOptions());
       
       app.UseHttpsRedirection();
       app.UseAuthorization();
       app.MapControllers();
       app.Run();
       
       

   11. Run the SOAP service.

       Launch the application and visit the specified endpoint to view the generated WSDL.

Consume WSDL in .NET 8

Create a .NET Core (.NET 8) WEB API project, same as shown in the above step.

Create client applications to consume the SOAP service. Visual Studio can help generate client code from the WSDL.

1. Generate reference code from a WSDL file. Right-click on “Manage Connected Services.”

   

2. Click on “Add a service reference.”

   

3. Select “WCF Web Service”

   

4. Insert the WSDL URI

   Click “Go,” and you’ll receive a list of services, methods, and a Namespace. Use this Namespace to reference methods in the project.

   

5. Clicking “Next” allows configuration,

   such as specifying the type of collections to generate. In this example, we’ll choose System.Collections.Generic.List.

   

6. In the final configuration screen,

   Choose between public/private classes and opt for synchronous or default asynchronous method generation.

   

7. Click “Finish” to initiate scaffolding, and your classes will be generated.

   

8. Once the process is complete,

   Find the connected service in the Solution Explorer, containing the generated reference with configured endpoints and methods.

   Choosing a synchronous method generates various available methods.

   

9. Create a new controller.

   To illustrate how to utilize the recently established connected service using the SOAP Client.

   To communicate with the connected service, create a client by referencing the Customer Reference. Indicate the endpoint to be used in the client.

   
   [ApiController]
   [Route("CustomerController")]
   public class CustomerController : Controller
   {
       [HttpGet]
       public async Task<CustomerDataContract> GetCustomersAsync()
       {
           ICustomerService customerService =
               new CustomerServiceClient(CustomerServiceClient.EndpointConfiguration.BasicHttpBinding_ICustomerService);
   
           return await customerService.GetCustomersAsync();
       }
   }
   

10. Execute the project and perform testing in Swagger.

    

Conclusion

The pattern itself is not complicated: data contract, service interface, implementation class, endpoint in Program.cs. A few minutes of setup and you have a working WSDL.

Production use cases follow the same model. Banks use SOAP because the strict contract gives them message-level auditability – REST over JSON does not enforce that at the protocol layer. SAP and Oracle ship SOAP APIs for similar reasons: WSDL guarantees type safety across language boundaries. Healthcare is a special case because HL7 is XML-native by spec, so SOAP fits without adding a translation layer.

Once the service is running, add WS-Security for message-level encryption, put the WSDL behind an API gateway, and write integration tests against a test host using the generated proxy class.

Satva Solutions provides ASP.NET Core API integration services for teams on .NET 8 and .NET 9. If your project needs SOAP alongside REST or event-driven components, get in touch.

Next, read this:

FAQs

What is WSDL in C#?

WSDL (Web Services Description Language) defines the structure of a SOAP web service, including operations, inputs, outputs, and endpoints used in C# applications.

How do you call a SOAP web service in C#?

You can call a SOAP web service in C# by adding a service reference in Visual Studio or using HttpClient to send XML-based SOAP requests.

Does ASP.NET Core support SOAP services?

ASP.NET Core does not natively support SOAP like WCF, but SOAP services can be implemented using libraries like CoreWCF or SoapCore.

Does .NET 8 support SOAP web services?

Yes, .NET 8 supports SOAP web services through external libraries such as SoapCore and CoreWCF for building and consuming SOAP APIs.

How do I generate a client proxy from a WSDL in .NET 8?

You can generate a SOAP client proxy in .NET 8 using Visual Studio Connected Services or the dotnet-svcutil CLI tool.

What is the difference between SOAP and REST?

SOAP is a protocol-based API standard that uses XML and WSDL, while REST is an architectural style that commonly uses JSON and HTTP methods.

When should you use SOAP instead of REST?

SOAP is preferred in enterprise applications that require strict security, formal contracts, and reliable transaction handling.

How do I secure a SOAP service in ASP.NET Core?

To secure a SOAP service in ASP.NET Core, enforce HTTPS, implement authentication and authorization, and follow standard API security practices.