Working with WCF Services through ASP.NET (A step-by-step guide)
Tags: dotnet, webdev, dotvvm
Published: 2020-09-10 21:15:16

Today there are many organizations that need to communicate and exchange data with external applications, in order to acquire web services with which they do not have and meet the needs of their potential customers. 

In more technical terms, our first objective is to implement the application logic of a particular system that accesses the database and provides web services for the manipulation of this data. From this, the second objective is to use these services, in order to worry only about the design of the corresponding web pages in this instance. 

####Web services with SOAP

SOAP web services, or "big" web services, are those that use XML messages for intercom, which follow the Simple Object Access Protocol (SOAP) standard, an XML language that defines the architecture and format of messages. Such systems typically contain a machine-readable description of the operations offered by the service, written in Web Services Description Language (WSDL), which is an XML-based language for defining interfaces syntactically.

####The overall idea of the solution:

This article has two main objectives. The first is about building a service-oriented application with WCF – Windows Communication Foundation, which will allow us to work with data hosted in a MySQL database as asynchronous messages from one service endpoint to another. The second objective is to use these services in a second project through a web page implemented with DotVVM on ASP.NET Core.

![](https://dev-to-uploads.s3.amazonaws.com/i/vlj8hik7hipvgqklpgw6.jpg)

Note: The source code used in this article is available on GitHub in the following repositories: [WCF (Windows Communication Foundation) Service on ASP.NET Framework](https://github.com/esdanielgomez/WCFService) and [Consuming WCF Service in DotVVM with ASP.NET Core](https://github.com/esdanielgomez/DotVVMConsumingWCFService). 

####Activities:

The article will have two important parts: 

+ Part 1: Implementing a Web Service with SOAP  
+ Part 2: Consuming SOAP services with DotVVM

####Resources needed:

To follow this article step by step or run the included demo, it is necessary to have the following tools: 

+ MySQL. 
+ .NET Core SDK. 
+ Visual Studio 2019.
+ The web development and ASP.NET workload for Visual Studio 2019.
+ The DotVVM extension for Visual Studio 2019. 

##**Part 1: Deploying a Web API with ASP.NET Core**
 
In this first part we will have three important parts: 

+ 1. Set the database. 
+ 2. Set database access from ASP.NET Framework through Entity Framework. 
+ 3. Establish a service contract and its operations. 

As a case study for this tutorial user data will be handled through CRUD operations: create, read, update, and delete.

####The database for the application domain

The database consists of a single table named: User, with attributes: `Id`, `FirstName`, `LastName`, `Username`, `Password` and `EnrrollmentDate`. 

![](https://dev-to-uploads.s3.amazonaws.com/i/6ucp3dy1i9n46fb6f0sr.png)

The SQL statement for creating the `User` table is as follows:

```sql
CREATE TABLE `user` (
  `Id` INT NOT NULL PRIMARY KEY,
  `FirstName` VARCHAR(45) NOT NULL,
  `LastName` VARCHAR(45) NOT NULL,
  `Username` VARCHAR(45) NOT NULL,
  `Password` VARCHAR(45) NOT NULL,
  `EnrollmentDate` datetime NOT NULL 
);
```

All right, with the database ready, we can start with the implementation of the first project for SOAP service development. 

####WCF Service Application Project   

In Visual Studio 2019 the first thing we'll do is create a new project of type WCF Service Application (within the C-Web category):

![](https://dev-to-uploads.s3.amazonaws.com/i/omn1x8b4uond3glham96.png)

With this project, we will create access to the database, the definition of the service interface, and the corresponding implementation, in this case, for the User entity. 

####Access to the database with Entity Framework  

To establish entities through classes and the database connection, you can use the Entity Framework Database First approach, which allows you to scaffold from the database to the project, that is, automatically generate classes according to the entities established in the database and the connection in the project. 

For this purpose, you need to install three NuGet packages:

+ `Microsoft.EntityFrameworkCore.Design`
+ `Microsoft.EntityFrameworkCore.Tools`
+ `MySql.Data.EntityFrameworkCore`

If you are working with SQL Server, the NuGet package to install will be: `Microsoft.EntityFrameworkCore.SQLServer`. 

Note: To find the NuGet Package Management Center, we can go to the options menu -> Project -> Handle NuGet Packages.

![](https://dev-to-uploads.s3.amazonaws.com/i/mfq8vvh6ll0fbm53yc6w.png)

With the installation of these NuGet packages, we will now open the Package Management Console to enter a command that will allow you to perform *scaffolding* from the database:

![](https://dev-to-uploads.s3.amazonaws.com/i/bzqtipn0ph5oe8xv1w96.png)

Command:

```
Scaffold-DbContext "server=servername;port=portnumber;user=username;password=pass;database=databasename" MySql.Data.EntityFrameworkCore -OutputDir DAL/Entities -f
```

The result is as follows:

![](https://dev-to-uploads.s3.amazonaws.com/i/k0bvp1wszh5anqc37m4v.png)

Here, the `User` class is defined as follows:

```csharp
public partial class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
    public DateTime EnrollmentDate { get; set; }
}
```

And the `DBContext`, which has the configuration with the database and will allow us to perform the corresponding operations on it.  

With these steps, we already have the connection and configurations necessary to work with the database in ASP.NET Core with the help of Entity Framework. 

####Set DTOs - Data Transfer Objects 

In order to transport the data between the processes for database management and operations to work with the web services, it is advisable to establish the DTO classes for each entity in the project, in this case, a DTO for the entity `User`.
 
To do this we will define a new folder within the project called DTO and create a class called `UserDTO`, whose attributes will be the same as the User class defined in the `Entities` section above:

```csharp
public class UserDTO
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
    public DateTime EnrollmentDate { get; set; }
}
```

####Service contracts 

The fundamental thing in a SOAP web service is the contract that exists between client and service, that is, the WSDL document. Therefore, when creating web services it is advisable to start by defining that contract. This way we'll have more control over the data that is serialized during service invocation, so we can define the data structures that we consider most appropriate for the exchange. In this case, we will define the operations to implement in the web service through an interface. The result will be as follows:

```csharp
[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]
public interface IService
{
    [OperationContract]
    List<UserDTO> Get();

    [OperationContract]
    UserDTO GetUserById(int Id);

    [OperationContract]
    bool InsertUser(UserDTO User);

    [OperationContract]
    void UpdateUser(UserDTO User);

    [OperationContract]
    void DeleteUser(int Id);
}
```

Then we must implement this interface, in which we will find the established methods, along with the operations necessary to receive and send the corresponding data. In this case, the file is in an extension of *.svc* and the code of the operations will be as follows:

*Initial definition:*

```csharp
public class Service : IService
{
    private readonly DBContext DBContext = new DBContext();

...
```

*A. Get the list of all registered users*

```csharp
public List<UserDTO> Get()
{
    return DBContext.User.Select(
        s => new UserDTO
        {
            Id = s.Id,
            FirstName = s.FirstName,
            LastName = s.LastName,
            Username = s.Username,
            Password = s.Password,
            EnrollmentDate = s.EnrollmentDate
        }
    ).ToList();
}
```

*B. Get the data of a specific user according to their ID*

```csharp
public UserDTO GetUserById(int Id)
{
    return DBContext.User.Select(
            s => new UserDTO
            {
                Id = s.Id,
                FirstName = s.FirstName,
                LastName = s.LastName,
                Username = s.Username,
                Password = s.Password,
                EnrollmentDate = s.EnrollmentDate
            })
        .FirstOrDefault(s => s.Id == Id);
}
```

*C. Insert a new user*

```csharp
public bool InsertUser(UserDTO User)
{
    var entity = new User()
    {
        FirstName = User.FirstName,
        LastName = User.LastName,
        Username = User.Username,
        Password = User.Password,
        EnrollmentDate = User.EnrollmentDate
    };

    DBContext.User.Add(entity);
    DBContext.SaveChangesAsync();

    return true;
}
```

*D. Update a specific user's data*

```csharp
public void UpdateUser(UserDTO User)
{
    var entity = DBContext.User.FirstOrDefault(s => s.Id == User.Id);

    entity.FirstName = User.FirstName;
    entity.LastName = User.LastName;
    entity.Username = User.Username;
    entity.Password = User.Password;
    entity.EnrollmentDate = User.EnrollmentDate;

    DBContext.SaveChangesAsync();
}
```

*E. Delete a user based on their ID*

```csharp
public void DeleteUser(int Id)
{
    var entity = new User()
    {
        Id = Id
    };

    DBContext.User.Attach(entity);
    DBContext.User.Remove(entity);
    DBContext.SaveChangesAsync();
}
```

The interface (.cs) and deployment (.svc) file will look like this within the Visual Studio solution:

![](https://dev-to-uploads.s3.amazonaws.com/i/nblg6d42fl7uy0w2s8hk.png)

With these few steps followed so far, the SOAP service for handling user data is ready to run. 

####Test the SOAP service developed

To test the deployed service we have several ways, one of them is to place ourselves in the SVC service implementation file and run the project. In this run, the WCF Test Client will be executed and will help us test the implemented functions.

In a first example we can test the Get() method and display the list of registered users, as we can see in the following image:

![](https://dev-to-uploads.s3.amazonaws.com/i/lid5awixztr2k61o5438.png)

Another case may be to get a specific user based on their ID, for this we will select the GetUserById() operation, and in this selection, the WCF test client will tell us the input parameters that we need to specify. The result is as follows:

![](https://dev-to-uploads.s3.amazonaws.com/i/uc14b2rygvtm5tq1ah87.png)

As an additional example, we can analyze the case of creating a new user through the InsertUser() operation, along with its corresponding input parameters:

![](https://dev-to-uploads.s3.amazonaws.com/i/ni26ntuqaf8ek2ai85nq.png)

All right, another way we can test our implemented SOAP services is through the Postman tool. In this case, we'll run the WCF project by placing us in any file within Visual Studio 2019 other than the SVC service implementation. Performing this run will open the browser with the information on this service. 
In Postman we will have to specify three things, on the one hand, the service binding, in this example will be: http://localhost:16260/Service.svc, whose selection will be in a POST method. Then we need to specify the headers according to the operation to be tested, in this case, we will exemplify the consumption with the GetUserById() operation:

`Content-Type`: `text/xml`
`SOAPAction`: `http://Microsoft.ServiceModel.Samples/IService/GetUserById`

Then we will have to specify the body XML with the input parameters to send, in this case, the user ID:

```xml
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
  <s:Body>
    <GetUserById xmlns="http://Microsoft.ServiceModel.Samples">
      <Id>1</Id>
    </GetUserById>
  </s:Body>
</s:Envelope>
```

Finally, when we make the request to the SOAP service we will get the XML response. The fields and results in Postman can be displayed in the following image:

![](https://dev-to-uploads.s3.amazonaws.com/i/ulrt0tvi12qfv2jbfhwx.png)

The call of the other operations will be seen when using these services directly from a web application with DotVVM.

##**Part 2: Consuming WCF services with DotVVM**

In this second part we will have two important parts: 

+ 1. Set methods for communication with SOAP services defined above. 
+ 2.Implement the views and models of these views for the development of the corresponding web page.  

The purpose of these web pages is to publicize the resulting data, from the consumption of CRUD operations: create, read, update, and delete set out in the SOAP service contract.

####DotVVM project with ASP.NET Core 

For this new purpose, in Visual Studio 2019 the first thing we'll do is create a new project of type DotVVM Web Application (.NET Core):

![](https://dev-to-uploads.s3.amazonaws.com/i/0tmup3i7obhlkt2uue48.png)

In DotVVM, communication between HTML (web pages) and C-code (source code) is done through the MVVM design pattern (Model, View, ViewModel). The purpose of these elements are as follows:

+ **The model**. — is responsible for all application data and related business logic.
+ **The view**. — Representations for the end-user of the application model. The view is responsible for displaying the data to the user and allowing manipulation of application data.
+ **Model-View or View-Model**. — one or more per view; the model-view is responsible for implementing view behavior to respond to user actions and for easily exposing model data.

####Set the reference with WCF Web Service

As the first point what we will need to do, is to establish a reference to the WCF service implemented earlier. For this purpose within the Visual Studio solution, we can go to the `Connected Services` section and select `Add Connected Service`:

![](https://dev-to-uploads.s3.amazonaws.com/i/44itg30aav6q7mjt5byi.png)

In the Connected Service Profiles section we will select the option: `Microsoft WCF Web Service Reference Provider`:

![](https://dev-to-uploads.s3.amazonaws.com/i/90wthc4grjzhedq3jatk.png)

From this selection, the `WCF Web Service Reference` configuration wizard will be initialized, and in this section, we will need to specify the URL with the WSDL metadata of the SOAP service, for this our WCF project must be running. 

In this example, the corresponding URL is: http://localhost:16260/Service.svc?wsdl. When loaded, the setup wizard will identify the service in question and the operations included. In this case, the last thing to define will be the name of the namespace where the classes and files within the project will be generated to access this service.

![](https://dev-to-uploads.s3.amazonaws.com/i/pbzyz4uh8guadg6r9vo0.png)

When you select Finish, the wizard will perform a scaffolding process, that is, generate the corresponding files to access this service.

![](https://dev-to-uploads.s3.amazonaws.com/i/mtdu1isnwhdfi9jt7o92.png)

At the end of the operation, we will see some classes and files like these:

![](https://dev-to-uploads.s3.amazonaws.com/i/04o1zubv2k66u5its6sj.png)
 
####Models and logic of the application 

Next, we need to implement the models and services that will consume the operations implemented in SOAP and set the logic of our application. In this case, what you are looking for is to have a general list of users and specific information on each of them.

To do this, as the first point we will define the models:

*A. UserListModel*

```csharp
public class UserListModel
{
    public int Id {get; set;}
    public string FirstName {get; set;}
    public string LastName {get; set;}
}
```

*B. UserDetailModel*

```csharp
public class UserDetailModel
{
    public int Id { get; set; }
    [Required]
    public string FirstName { get; set; }
    [Required]
    public string LastName { get; set; }
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    [Required]
    public DateTime EnrollmentDate { get; set; }
```

And then the logic services of our application. In this case we have the user service that will allow us to establish CRUD operations according to the service contracts in SOAP.

For User service initialization, we can start with a definition like this:

```csharp
ServiceClient reference = new ServiceClient();
```

This statement corresponds to the instantiation of one of the previously generated classes. From this base object for SOAP service consumption, the following are the corresponding methods:

*A. Get the list of all registered users*

```csharp
public List<UserListModel> GetAllUsers()
{
    return reference.GetAsync().Result.Select(
        s => new UserListModel
        {
            Id = s.Id,
            FirstName = s.FirstName,
            LastName = s.LastName
        }).ToList();
}
```

*B. Get the data of a specific user according to their ID*

```csharp
public async Task<UserDetailModel> GetUserByIdAsync(int Id)
{
    var result = await reference.GetUserByIdAsync(Id);

    return new UserDetailModel()
    {
        Id = result.Id,
        FirstName = result.FirstName,
        LastName = result.LastName,
        Username = result.Username,
        Password = result.Password,
        EnrollmentDate = result.EnrollmentDate
    };
}
```

*C. Insert a new user*

```csharp
public async Task InsertUserAsync(UserDetailModel user)
{
    UserDTO NewUser = new UserDTO() {
        Id = user.Id,
        FirstName = user.FirstName,
        LastName = user.LastName,
        Username = user.Username,
        Password = user.Password,
        EnrollmentDate = user.EnrollmentDate
    };

    await reference.InsertUserAsync(NewUser);
}
```

*D. Update a specific user's data*

```csharp  
public async Task UpdateUserAsync(UserDetailModel user)
{
    UserDTO UserToUpdate = new UserDTO()
    {
        Id = user.Id,
        FirstName = user.FirstName,
        LastName = user.LastName,
        Username = user.Username,
        Password = user.Password,
        EnrollmentDate = user.EnrollmentDate
    };

    await reference.UpdateUserAsync(UserToUpdate);
}
```

*E. Delete a user based on their ID*

```csharp  
public async Task DeleteUserAsync(int Id)
{
    await reference.DeleteUserAsync(Id);
}
```

####Views and viewmodels

Now that the methods that consume the services in XML format have been defined, we now only have to design the web page so that the user can interact with it and in this case, perform CRUD operations for user handling. 

Each page in DotVVM consists of two files:

+ *A view*, which is based on HTML syntax, and describes what the page will look like. 
+ *A view model*, a class in C-class that describes the state of the page (for example, values in form fields) and handles user interactions (for example, button clicks).

For our case we will have four views and four models associated with these views:

+ *Default:* will be the main page of the application where the list of registered users will be displayed. 
+ *Create:* a page consisting of a form to create new users. 
+ *Detail:* to see a student's information in detail. 
+ *Edit:* to modify or delete a student's information. 

Considering the *Views* and *Viewmodels* files, in Visual Studio we'll see something like this:

![](https://dev-to-uploads.s3.amazonaws.com/i/yb4j9uszz8wpjw0ypzl3.png)

Next, let's take a closer look at the *View* and *Viewmodel* of `Default` and its components. 

**Default Viewmodel**

```csharp
public class DefaultViewModel : MasterPageViewModel
{
    private readonly UserService userService;

	public DefaultViewModel(UserService userService)
    {
        this.userService = userService;
    }

    [Bind(Direction.ServerToClient)]
    public List<UserListModel> Users { get; set; }

    public override async Task PreRender()
    {
        Users = userService.GetAllUsers();
        await base.PreRender();
    }
}
```

As a first point, we have the instance of `UserService` that will allow us to access the methods to handle the operations defined in the `User` service implemented previously.

Then we have the definition `List<UserListModel> Students` of type `UserListModel` defined in the model classes, which will have the list of users (`Id`, `FirstName` and `LastName`) to load them into a table on the main page of the web application. 

Finally, in the *Viewmodel* of `Default` we have the method `PreRender()`, which allows us to perform certain kinds of operations that will be performed at the time of loading the View. In this case, the database will be queried through the service method call `userService.GetAllUsersAsync()`, then the results will be assigned to the Users collection of type `UserListModel` and then the page will be loaded along with the other layout components. 

**Default View**

```html
@viewModel DotVVM.ViewModels.DefaultViewModel, DotVVM
@masterPage Views/MasterPage.dotmaster
<dot:Content ContentPlaceHolderID="MainContent">
	<div class="page-center">
		<div class="page-grid-top">
		<div class="student-image"></div>
			<h1>User List</h1>
			
				<dot:RouteLink Text="New User" RouteName="CRUD_Create" class="page-button btn-add btn-long"/>
			
		</div>
		<dot:GridView DataSource="{value: Users}" class="page-grid">
			<Columns>
				<dot:GridViewTextColumn ValueBinding="{value: FirstName}" HeaderText="Firstname" />
				<dot:GridViewTextColumn ValueBinding="{value: LastName}" HeaderText="Lastname" />
				<dot:GridViewTemplateColumn>
					<dot:RouteLink Text="Detail" RouteName="CRUD_Detail" Param-Id="{{value: Id}}" />
				</dot:GridViewTemplateColumn>
				<dot:GridViewTemplateColumn>
					<dot:RouteLink Text="Edit" RouteName="CRUD_Edit" Param-Id="{{value: Id}}" />
				</dot:GridViewTemplateColumn>
			</Columns>
			 <EmptyDataTemplate>
                There are no registered users. 
            </EmptyDataTemplate>
		</dot:GridView>
	</div>
</dot:Content>
```

As we can see from the Default View, the page layout becomes the handling of HTML and CSS statements. For our case study, there are some interesting statements and features that we can analyze: 

`GridView: <dot:GridView ... >`, a DotVVM control that allows us to create a table or crew to display a certain list of information. In HTML we would be talking about the tag `<table>`. One of its attributes is `DataSource`: `DataSource`, which allows you to specify the data source, in this case, we refer to the list of students: `Users`, which was defined in the *Viewmodel* as we saw above.  

In addition to tables, DotVVM also has other custom control components, for example, for text boxes, ComboBox, file handling, among others that allow us to maintain communication between the View and the information sources defined in *Viewmodels*. 

Continuing with our analysis, in the `GridView` we have the columns `Id`, `FirstName`, and `LastName` of the users, but additionally, we can also add columns to perform operations on some specific record. In this case, with `RouteLink`, we can define a hyperlink that constructs a URL from path names and parameter values to redirect us to other pages or perform additional operations, for example, view detail or modify a particular student's record based on their ID:

```html
<dot:RouteLink RouteName="Edit" Param-Id="{{value: Id}}" />
```

These routes and their corresponding parameters are defined in the `DotvvmStartup.cs` file in the `ConfigureRoutes` method as follows:

```csharp
config.RouteTable.Add("Edit", "edit/{Id}", "Views/Edit.dothtml");  
```

To create, view detail, and modify pages, the same logic is followed for the View and ViewModel components.

####Execution of solutions 

Up to this point, we have implemented two solutions, the first to provide SOAP services through a WCF project, and the second, consume these services through a web application with DotVVM. To test locally, both Visual Studio solutions must run before you can enable the SOAP service and consume it in turn. Below we can see some screenshots about the deployed web application:  

+ *Create a new record*

![](https://dev-to-uploads.s3.amazonaws.com/i/fk5mn8fncvidgx6tu9jr.png)

+ *Get the detail of a specific record*

![](https://dev-to-uploads.s3.amazonaws.com/i/78lur27swt44ytqehfys.png)

+ *General list of users*

![](https://dev-to-uploads.s3.amazonaws.com/i/r2u8htpmgyenqgyypjmb.png)

##**What's next?**
 
With this article, we've learned step-by-step how to implement SOAP services that handle database information with ASP.NET Core and how to consume it through a Project with DotVVM. 

The source code for the two projects used in this article is available in the following GitHub repositories: [WCF (Windows Communication Foundation) Service on ASP.NET Framework](https://github.com/esdanielgomez/WCFService) and [Consuming WCF Service in DotVVM with ASP.NET Core](https://github.com/esdanielgomez/DotVVMConsumingWCFService).  

####Thank you for reading:

I hope you liked the article. To stay on top of future contributions or if you have any concerns, you can follow me on Twitter: [twitter.com/esDanielGomez](https://twitter.com/esDanielGomez).

See you soon!