What is Clean Architecture: Part 14-last step in Application Core Layer

When building applications with clean architecture, it’s essential to register the services that your application depends on in a clean and centralized manner. This is typically done in the application core layer. In this article, we will look at how to create a centralized service registration for core services such as AutoMapper, MediatR, and any other service needed, like Fluent Validation.

The Purpose of Application Core Service Registration

The application core layer is where we handle most of the business logic, and it is crucial that services such as mapping, request handling, and validation are made available to the rest of the application in a systematic way.

A centralized service registration ensures that:

• All necessary services are registered in one place.
• The application layer is decoupled from the infrastructure or external concerns.
• It’s easier to add or remove services as the application evolves.

Step 1: Creating the ApplicationServiceRegistration Class

The first step in setting up service registration is to create a static class that will contain the method to register services.

Here’s a simple example of the ApplicationServiceRegistration class:

namespace GloboTicket.TicketManagement.Application
{
    public static class ApplicationServiceRegistration
    {
        public static IServiceCollection AddApplicationServices(this IServiceCollection services)
        {
            services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
            services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblies(AppDomain.CurrentDomain.GetAssemblies()));

            return services;
        }
    }
}

In this class, we define a method AddApplicationServices that extends the IServiceCollection interface and registers the core services required by the application. Let’s break this down:

• AutoMapper: This is a library that helps map objects from one type to another. By using AddAutoMapper, we automatically register all mapping profiles in the application domain.

  services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());

• MediatR: This library helps implement the Mediator pattern for handling requests (commands and queries) without tight coupling between components. The call to AddMediatR registers the handlers for the requests.

  services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblies(AppDomain.CurrentDomain.GetAssemblies()));

Step 2: Extending the Core with Fluent Validation

If you’re using Fluent Validation for your validation needs, you can extend the service registration to include validation by adding the following:

services.AddValidatorsFromAssemblyContaining<CreateEventCommandValidator>();

This registers all validators in the assembly, making them available throughout the application.

Updated ApplicationServiceRegistration:

public static IServiceCollection AddApplicationServices(this IServiceCollection services)
{
    services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
    services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblies(AppDomain.CurrentDomain.GetAssemblies()));
    services.AddValidatorsFromAssemblyContaining<CreateEventCommandValidator>();

    return services;
}

In this example, we’ve registered validators by referencing one of the validators (CreateEventCommandValidator). Fluent Validation will automatically pick up all validators in the same assembly.

Step 3: Using the Service Registration

Once the ApplicationServiceRegistration class is set up, you need to call the AddApplicationServices method from the Startup.cs or Program.cs (depending on your .NET version) to register all these services at the application level.

For example, in ASP.NET Core, this might look like:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddApplicationServices();  // Registers all services from the application core layer
    }
}

This call ensures that all necessary services, like AutoMapper, MediatR, and Fluent Validation, are registered and available throughout the application.

Conclusion

By centralizing service registration in the application core layer, we adhere to the principles of clean architecture and ensure that the core logic of the application remains isolated from external concerns. This approach makes it easier to maintain and extend the application as the number of services grows.

Using the ApplicationServiceRegistration class, you can register essential services like AutoMapper, MediatR, and Fluent Validation in one place, making your code cleaner and more maintainable.