Connecting to a Multi-Tenant API using the MVP Design Pattern in .NET

In modern software architectures, building scalable and maintainable applications is essential. One approach that helps to manage the complexity of multi-tenant systems is the use of the Model-View-Presenter (MVP) design pattern. In this blog, we’ll walk through how to implement this design pattern for connecting to a multi-tenant API in a .NET application. This blog will cover the following aspects:

• Setting up the .NET project
• Understanding the MVP design pattern
• Connecting to a Multi-Tenant API
• Detailed code implementation and explanation

🔧 Step 1: Setting Up the .NET Project

Before diving into the code, let’s start by setting up the .NET project. We'll create a new Razor Pages application for this example, which is suitable for web-based applications. Follow these steps:

1. Create a New .NET Web Application

Open a terminal or Visual Studio and run the following command to create a new Razor Pages project:

dotnet new webapp -n MultiTenantMVP
cd MultiTenantMVP
  

2. Install Dependencies

We'll need to install the HttpClient package for making API requests to the multi-tenant system. To install it, run the following:

dotnet add package Microsoft.Extensions.Http
  

3. Project Folder Structure

We’ll structure the project to follow the MVP pattern. Here’s the breakdown of the folder structure:

• Models: Contains data models and the API client for communicating with the multi-tenant API.
• Views: Contains the UI (in this case, Razor Pages) where the data is displayed.
• Presenters: Contains the business logic, interacts with the API client, and updates the View.

🎨 Step 2: Understanding the MVP Design Pattern

The MVP pattern is a way to organize the code in a way that promotes separation of concerns. In the MVP pattern:

• Model: Represents the data layer and contains business logic or API interactions.
• View: Represents the user interface and is responsible for displaying the data. It is passive and delegates the logic to the Presenter.
• Presenter: Acts as the intermediary between the View and the Model. It retrieves data from the Model and updates the View.

🔗 Step 3: Connecting to a Multi-Tenant API

In a multi-tenant system, each tenant has its own data, configuration, and API endpoint. We’ll build a simple solution where each tenant has its own API key and base URL. The Presenter will retrieve data based on the current tenant’s configuration and display it through the View.

1. Tenant Configuration

Each tenant has unique configuration data, including an API URL and an API key. Let's define a TenantConfig model to represent this configuration.

public class TenantConfig
{
    public string TenantId { get; set; }
    public string ApiBaseUrl { get; set; }
    public string ApiKey { get; set; }
}
  

2. Implementing the API Client

The TenantApiClient will be responsible for making HTTP requests to the multi-tenant API based on the current tenant’s configuration. It will use HttpClient to communicate with the API.

public class TenantApiClient
{
    private readonly HttpClient _httpClient;
    private readonly TenantConfig _tenantConfig;

    public TenantApiClient(HttpClient httpClient, TenantConfig tenantConfig)
    {
        _httpClient = httpClient;
        _tenantConfig = tenantConfig;
    }

    public async Task GetTenantDataAsync()
    {
        _httpClient.DefaultRequestHeaders.Add("x-api-key", _tenantConfig.ApiKey);
        var response = await _httpClient.GetAsync($"{_tenantConfig.ApiBaseUrl}/data");
        return await response.Content.ReadAsStringAsync();
    }
}
  

3. Implementing the Presenter

The Presenter will use the TenantApiClient to fetch the tenant-specific data and pass it to the View to be displayed.

public class TenantPresenter
{
    private readonly ITenantView _view;
    private readonly TenantApiClient _apiClient;

    public TenantPresenter(ITenantView view, TenantApiClient apiClient)
    {
        _view = view;
        _apiClient = apiClient;
    }

    public async Task LoadTenantDataAsync()
    {
        try
        {
            var data = await _apiClient.GetTenantDataAsync();
            _view.DisplayData(data);
        }
        catch (Exception ex)
        {
            _view.DisplayError($"Failed to load tenant data: {ex.Message}");
        }
    }
}
  

4. Setting Up the View

The View will be a Razor Page or MVC controller that delegates the logic to the Presenter. The View will call the Presenter to load the tenant data and display it accordingly.

public interface ITenantView
{
    void DisplayData(string data);
    void DisplayError(string message);
}
  

📂 File Structure

The file structure of our project should look something like this:

MultiTenantMVP/
|-- Models/
|   |-- TenantConfig.cs
|   |-- TenantApiClient.cs
|
|-- Presenters/
|   |-- TenantPresenter.cs
|
|-- Pages/
|   |-- Index.cshtml.cs
|
|-- Startup.cs
|-- appsettings.json
  

✅ Process Flow

1. The View sends a request to the Presenter to load data.
2. The Presenter interacts with the Model (TenantApiClient) to fetch the tenant-specific data.
3. The Model makes an HTTP request to the Multi-Tenant API, using the appropriate configuration (API URL, API Key, etc.).
4. The Model returns the fetched data to the Presenter.
5. The Presenter updates the View with the received data or an error message.

✅ Pros of Using MVP for Multi-Tenant APIs

• Separation of Concerns: MVP helps in maintaining clear separation between the UI and business logic.
• Testability: With the Presenter interacting with the View through interfaces, it becomes easier to unit test business logic.
• Maintainability: The code is more modular, which makes it easier to maintain and scale as the number of tenants grows.
• Scalability: New tenants or features can be added without disrupting the entire codebase.

⚠️ Cons of Using MVP

• Complexity: The MVP pattern can introduce some additional complexity, especially in smaller applications.
• Boilerplate Code: There is more boilerplate code to set up, particularly for managing the interfaces and separate classes.

🚀 Conclusion

In this blog, we demonstrated how to use the MVP Design Pattern to connect to a multi-tenant API in .NET. By following the steps outlined here, you can build scalable and maintainable systems that separate business logic, data retrieval, and UI components. The MVP pattern allows for easier testing, maintenance, and extension of your application.