Working with web services through ASP.NET Core and DotVVM (A step by step guide)
Tags: webdev, dotnet, csharp, ap
Published: 2020-06-24 17:04:54

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, the first goal is to implement the backend of a given system that accesses the database and provides services for the manipulation of this data. From this, the second objective is to use these services, either from a website or from a mobile application, in order to worry only about the design of the frontend in this second instance.

####Overall idea of the solution:####

For this article, we have two objectives. The first is about building a Rest API that will make available web services for the handling of data from a database with MySQL. The second objective is to use these services in a second project through a web page implemented with DotVVM.

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

**Note**: The source code used in this article is available on GitHub in the following repositories: [REST API with ASP.NET Core and MySQL](https://github.com/esdanielgomez/ASP.NET_WebAPI) and [Consuming Web API in DotVVM with ASP.NET Core](https://github.com/esdanielgomez/DotVVMConsumingWebAPI).

####Activities:####

The article will have two important parts: 

+ Part 1: Developing a Web API with ASP.NET Core 
+ Part 2: Consuming HTTP Web 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 in operation:

+ 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: Developing 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 Core through Entity Framework. 
+ 3. Set controllers and their functionalities. These methods will be responsible for providing web services for later use.

As a case study for this tutorial will handle user information 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: `Int`, `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 `user2` (
  `Id` INT NOT NULL AUTO_INCREMENT 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 
) AUTO_INCREMENT=1;

```
All right, with the database ready we can start with the implementation of the first project for the development of API Rest services.

####ASP.NET Core project with Web API type

In Visual Studio 2019, the first thing we'll do is create a new project of type ASP.NET Core Web Application (within the .NET Core - C# category):

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

After specifying the project name, we will select the type template: API, for the ASP.NET Core Web project to create:

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

With this project, we will create access to the database and implement the corresponding driver, in this case, for the User class.

####Access to the database with Entity Framework

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

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

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

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

**Note**: To find the NuGet Package Admin 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 scaffold 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 Entities -f
```
The result is as follows:

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

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, whose main method `OnConfiguring` will look something like this:

```csharp
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {                optionsBuilder.UseMySQL("server=localhost;port=3306;user=root;password=;database=database");
            }
        }

```
Now, it is not as appropriate as the database connection string is specified in this `OnConfiguring` method, to do this, we will specify the connection string in the `appsettings.json` file as follows:

```csharp
"AllowedHosts": "*",
"ConnectionStrings": {
  "DefaultConnection": "server=servername;port=portnumber;user=username;password=pass;database=databasename;"
}
```
Then, in the `Startup` class in `ConfigureServices` method we add as a service to the `DBContext` and reference the `DefaultConnection` property specified in the `appsettings.json` file:

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddEntityFrameworkMySQL()
        .AddDbContext<DBContext>(options =>
        {
            options.UseMySQL(Configuration.GetConnectionString("DefaultConnection"));
        });
    services.AddControllers();
}
```
In this case, by returning to the `DBContext` class, we clear the connection string specified in the `OnConfiguring` method. In the end, we would have the empty method:

```csharp
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{}
```

And the constructor of the `DBContext` would be constituted as follows:

```
public DBContext(DbContextOptions<DBContext> options)
    : base(options) {}
```
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 the processes to work with the web services, it is advisable to establish the DTO classes for each entity of the project, in this case, a DTO for the User entity. 

To do this we will create 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; }
}
```

####Web API Controllers####

Now what we'll do is add the handlers, in this case, the driver for the user, which will allow us to set methods to perform CRUD operations on the database tables and expose them through the Web API. Above the `Controllers` folder, we'll add a driver called `User`:

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

The definition of the class and its constructor will look like this:

```csharp
[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    private readonly DBContext DBContext;

    public UserController( DBContext DBContext)
    {
        this.DBContext = DBContext;
    }
    ...
}
```
Now the goal is to implement the methods of this controller to perform CRUD operations. At this point it is important to mention the basic methods of HTTP. These methods are:

+ **POST (create)**: This is a method for when sending information to insert a record into the database for example. The information is sent in the body of the request, that is, the data is not visible to the user.
+ **GET (read)**: This is a method used for a read mode, for example: when you want to list all users in a database. Parameters are sent by a URL.
+ **PUT (update)**: This is a method for when you want to update a record. 
+ **DELETE**: This is a method for when you want to delete a record. Delete an X user from a database.

For the implementation of CRUD operations, we will use methods to access the information (Get), to insert data (Post), to modify (Put), and to delete a record (Delete).

The final code for each of the methods is shown below:

**A. Get the list of all registered users**

```csharp
[HttpGet("GetUsers")]
public async Task<ActionResult<List<UserDTO>>> Get()
{
    var List = await DBContext.User.Select(
        s => new UserDTO
        {
            Id = s.Id,
            FirstName = s.FirstName,
            LastName = s.LastName,
            Username = s.Username,
            Password = s.Password,
            EnrollmentDate = s.EnrollmentDate
        }
    ).ToListAsync();

    if (List.Count < 0)
    {
        return NotFound();
    }
    else
    {
        return List;
    }
}
```

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

```csharp
[HttpGet("GetUserById")]
public async Task<ActionResult<UserDTO>> GetUserById(int Id)
{
    UserDTO User = await DBContext.User.Select(
            s => new UserDTO
            {
                Id = s.Id,
                FirstName = s.FirstName,
                LastName = s.LastName,
                Username = s.Username,
                Password = s.Password,
                EnrollmentDate = s.EnrollmentDate
            })
        .FirstOrDefaultAsync(s => s.Id == Id);

    if (User == null)
    {
        return NotFound();
    }
    else
    {
        return User;
    }
}
```

**C. Insert a new user**

```csharp
[HttpPost("InsertUser")]
public async Task<HttpStatusCode> 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);
    await DBContext.SaveChangesAsync();

    return HttpStatusCode.Created;
}
```

**D. Update the data of a specific user**

```csharp
[HttpPut ("UpdateUser")]
public async Task<HttpStatusCode> UpdateUser(UserDTO User)
{
    var entity = await DBContext.User.FirstOrDefaultAsync(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;

    await DBContext.SaveChangesAsync();
    return HttpStatusCode.OK;
}
```

**E. Delete a user based on their ID**

```csharp
[HttpDelete("DeleteUser/{Id}")]
public async Task<HttpStatusCode> DeleteUser(int Id)
{
    var entity = new User()
    {
        Id = Id
    };
    DBContext.User.Attach(entity);
    DBContext.User.Remove(entity);
    await DBContext.SaveChangesAsync();
    return HttpStatusCode.OK;
}
```

With these methods and with the steps followed up to this point, the services are ready to run.

####Test the developed Web API

To test the deployed Web API we will make use of Postman, a cross-platform tool that allows you to do REST API testing. The installer can be found at the following address: [https://www.postman.com/downloads/](https://www.postman.com/downloads/). 

Build and run our application from Visual Studio 2019:

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

Once Postman is started, we can perform the first test. Below, we can see the use of the service to recover all registered users: 

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

As we can see in the image, it is necessary to specify the type of operation, in this case, it is of type GET, as specified in the user driver. Also, we can see that the status of the result is 200 OK – that is, everything went well. And finally, we can see in the response the JSON with the results.

An additional example we can see the case to get a specific user:

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


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

In this second part we will have three important parts: 

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

The goal with web pages is to consume CRUD operations: create, read, update, and delete set in HTTP services.

####DotVVM project with ASP.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:

+ **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 the 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.

####Models and logic of the application

In this first part, we will define the models and services to consume HTTP services 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:

**UserList**

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

**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 services of our application. In this case we have the user service that will allow us to set the CRUD operations according to the HTTP methods.

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

```csharp
public class UserService
{
    private readonly string URLbase = "https://localhost:5003/api/User";
    …
```

From the base address for HTTP service consumption, the following are the corresponding methods: 

**A. Get the list of all registered users**

```csharp
public async Task<List<UserListModel>> GetAllUsersAsync()
{
    List<UserListModel> usersList = new List<UserListModel>();
    using (var httpClient = new HttpClient())
    {
        string URL = URLbase + "/GetUsers";
        HttpResponseMessage response = await httpClient.GetAsync(URL);
        string apiResponse = await response.Content.ReadAsStringAsync();
        usersList = JsonConvert.DeserializeObject<List<UserListModel>>(apiResponse).Select(
            s => new UserListModel
            {
                Id = s.Id,
                FirstName = s.FirstName,
                LastName = s.LastName
            }
            ).ToList();
    }
    return usersList;
}
```

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

```csharp
public async Task<UserDetailModel> GetUserByIdAsync(int Id)
{
    string URL = URLbase + "/GetUserById?id=" + Id;
    UserDetailModel User = new UserDetailModel();

    using (var httpClient = new HttpClient())
    {
        HttpResponseMessage response = await httpClient.GetAsync(URL);
        string apiResponse = await response.Content.ReadAsStringAsync();
        User = JsonConvert.DeserializeObject<UserDetailModel>(apiResponse);
    }
    return User;
}
```

**C. Insert a new user**

```csharp
public async Task InsertUserAsync(UserDetailModel user)
{
    string URL = URLbase + "/InsertUser";
            
    using (var httpClient = new HttpClient())
    {
        StringContent content = new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json");
        HttpResponseMessage response = await httpClient.PostAsync(URL, content);
        string apiResponse = await response.Content.ReadAsStringAsync();       
    }
}
```

**D. Update a specific user's data**

```csharp
public async Task UpdateUserAsync(UserDetailModel user)
{
    string URL = URLbase + "/UpdateUser";

    using (var httpClient = new HttpClient())
    {
        StringContent content = new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json");

        HttpResponseMessage response = await httpClient.PutAsync(URL, content);
        string apiResponse = await response.Content.ReadAsStringAsync();
    }
}
```

**E. Delete a user based on their ID**

```csharp
public async Task DeleteUserAsync(int Id)
{
    string URL = URLbase + "/DeleteUser/" + Id;

    using (var httpClient = new HttpClient())
    {
        var response = await httpClient.DeleteAsync(URL);
        string apiResponse = await response.Content.ReadAsStringAsync();
    }
}
```

####Views and viewmodels

Now that the methods consuming HTTP services 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. 

This is the part where DotVVM comes into action. 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 model of the view*, that is, a class in CTM 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*: it will be the main page of the application where the list of registered users will be displayed. 

+ *Create*: A page made up of a form to create new users. 

+ *Detail*: To see a user's information in detail. 

+ *Edit*: to modify a user's information or delete it. 

Considering the Views and Viewmodels files, in Visual Studio we'll visualize 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.

**Viewmodel del Default**

```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 = await userService.GetAllUsersAsync();
        await base.PreRender();
    }
}
```

As the 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> Users` 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. 

A very important feature to mention is the declaration `[Bind(Direction.ServerToClient)]`. This type of property allows us to specify which information to be transferred from the server to the client or from the client to the server when using *Binding Directions*. Considering the case of the user list, it is often not necessary to transfer the entire view model in both directions. From the server to the view will suffice in this case.

Learn more about Binding Directions here: 
[https://www.dotvvm.com/docs/tutorials/basics-binding-direction/2.0](https://www.dotvvm.com/docs/tutorials/basics-binding-direction/2.0).

Finally, in `Default` Viewmodel 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 design components.

**View de Default**

```html
@viewModel DotVVM_APIConsume.ViewModels.DefaultViewModel, DotVVM_APIConsume
@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 the View of `Default`, 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 grid to display a certain list of information. In HTML we would be talking about the tag `<table>`. One of its attributes is DataSource: `DataSource="{value: Users}"` which allows us to specify the data source, in this case we refer to the list of users: 'Users', which was defined in the Viewmodel as we saw earlier.  

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 the Viewmodels. See more here: [https://www.dotvvm.com/docs/controls/](https://www.dotvvm.com/docs/controls/).

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 route 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:

``` csharp
<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 learn more about Routing in DotVVM you can go here: [https://www.dotvvm.com/docs/tutorials/basics-routing/2.0](https://www.dotvvm.com/docs/tutorials/basics-routing/2.0).

The Create, View Detail, and Modify pages follow the same logic for the View and Viewmodel components.

####Execution of solutions

Up to this point, we have implemented two solutions, the first to provide HTTP services over ASP.NET Core, and the second, to consume these services through a web application with DotVVM. To test locally, both Visual Studio solutions must run in order to enable HTTP services and consume them 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 have learned step by step how to implement HTTP services that handle database information with ASP.NET Core and how to consume them through a project with DotVVM. 

The next activity is to publish these cloud services so that they can be accessed from anywhere. In Azure, for example, the process for uploading a Web API project or a project made up of web pages is the same. The steps to carry out this process can be found in the following article: [Deploy DotVVM and .NET Core web applications to Azure (Everything you need to know)](https://dev.to/dotvvm/deploy-dotvvm-and-net-core-web-applications-to-azure-everything-you-need-to-know-3651). 

The source code of the two projects used in this article is available in the following GitHub repositories: [REST API with ASP.NET Core and MySQL](https://github.com/esdanielgomez/ASP.NET_WebAPI) and [Consuming Web API in DotVVM with ASP.NET Core](https://github.com/esdanielgomez/DotVVMConsumingWebAPI). 

####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!