DEV Community: Zenrac

Generate your own application with the CQRS design pattern thanks to JHipster.NET

Zenrac — Fri, 23 Jul 2021 14:18:41 +0000

Overview

JHipster is a famous generator allowing you to generate modern applications.

One of its official blueprints is called JHipster.NET. It allows to override the back-end part in asp.net core (instead of Java spring boot).

To take advantage of this blueprint, we will generate a modern application which implements the Mediator and CQRS pattern.

Why CQRS ?

CQRS stands for Command Query Responsibility Segregation. In .NET you have the possibility to easily implement this pattern thanks to MediatR.

This pattern separates a service’s write tasks from its read tasks. While reading and writing to the same database is acceptable for small applications, distributed applications operating at web-scale require a segmented approach.

Pros

Modern pattern that is more and more used in many projects.
It’s secure, it allows to make sure that queries are not able to do “write” operations, as they souldn’t do.
Separating write and read activities allows you to use the best database technology for the task at hand, for example, a SQL database for writing and a non-SQL database for reading.
It also helps with balance loading and performance balancing. Read activity tends to be more frequent than writing, you can reduce response latency by placing read data sources in strategic geolocations for better performance.

Cons

You have to ensure that your data is consistant between your database.
This pattern is difficult/nearly impossible to implement to an already existing project.

Hopefully, thanks to JHipster implementing CQRS to your application isn’t a big deal.

MediatR

In order to easily implement the CQRS pattern, JHipster uses MediatR which implements the Mediator pattern.

The Mediator pattern adds a layer called Application which allows to separate your commands and queries. Meaning that your controllers delegate all the CRUD logic to your Application layer, then your Application layer finds which database it needs to interact with, which service/repository to use etc...

Taking advantage of MediatR to implements CQRS

The easiest way to implement CQRS with the Mediator pattern is to add ReadOnlyRepositories. Those repositories will be used by queries, when your commands will use the original repositories. Thanks to that, your commands and queries will be separated.

CQRS with JHipster

Installation

You may find more information about how to generate your ASP.NET Core application with JHipster.NET in this post.

When generating your application, you can choose to use CQRS.

Make sure to answer Y to enable CQRS.

Enabling it will generate a new “Application” layer (a new solution in your C#) for your commands and queries.

├── Namespace.Application
│   ├── Commands                             - Your commands
│   │   ├── MyEntity                         - Your entity
│   │   │   ├── MyEntityCreateCommand        - A command
│   │   │   ├── MyEntityCreateCommandHandler - A command handler
│   ├── Queries                              - Your queries
│   │   ├── MyEntity                         - Your entity
│   │   │   ├── MyEntityGetQuery             - A query
│   │   │   ├── MyEntityGetQueryHandler      - A query handler
├── Namespace.Crosscutting
├── Namespace.Domain
├── Namespace.Domain.Services
├── Namespace.Dto
├── Namespace.Infrastructure

How to create queries/commands

In order to create your own commands and/or queries you have to create two classes :

A command/query
An handler for it

Automatically

JHipster allows to automatically generates entities. Read this article to get started. Of course it will automatically generates your entities following the CQRS pattern with their commands/queries.

Manually

If you want to create your very own commands/queries, here’s an example :
First, let’s create a query MyEntityGetQuery.cs:

namespace MyCompany.Application.Queries {
    public class MyEntityGetQuery : IRequest<MyEntity>
    {
        public long Id { get; set; }
    }
}

This Query should have an Id and returns a MyEntity object. Here’s the handler MyEntityGetQueryHandler.cs :

namespace MyCompany.Application.Queries {
    public class MyEntityGetQueryHandler : IRequestHandler<MyEntityGetQuery, MyEntity>
    {
        private IReadOnlyMyEntityRepository _myEntityRepository;
        public MyEntityGetQueryHandler(IReadOnlyMyEntityRepository myEntityRepository)
        {
            _myEntityRepository = myEntityRepository;
        }
        public Task<MyEntity> Handle(MyEntityGetQuery request,
            CancellationToken cancellationToken)
        {
            return _myEntityRepository.QueryHelper()
                .GetOneAsync(myEntity => myEntity.Id == request.Id);
        }
    }
}

Please note that we are using a ReadOnlyRepository rather than a service in order to do the segregation between Commands and Queries. Lastly, create your routing method within your controller :

[HttpGet("my-entity/{id}")]
public async Task<IActionResult> GetMyEntity([FromRoute] long id)
{
    var result = await _mediator.Send(new MyEntityGetQuery { Id = id });
    return ActionResultUtil.WrapOrNotFound(result);
}

Conclusion

Now you should be able to generate a modern CQRS Application thanks to JHipster !
Feel free to contribute to JHipster.NET’s GitHub repository and don’t forget to put a star if you liked it.

Generate your own application with End-to-End testing thanks to JHipster.NET

Zenrac — Fri, 23 Jul 2021 14:12:29 +0000

Introduction

When generating your application with JHipster.NET, you can decide to generate some optional Tests :

Performance tests with Gatling.
Behaviour-driven tests with Cucumber.
Angular/React/Vue integration tests with Cypress.

Today we're going to talk about Cypress, a next generation front end testing tool built for the modern web.

Generate Cypress tests

When generating your application, make sure to select Cypress (by pressing the space bar).

Run your Cypress tests

Once your application is generated, you can optionally add some entities (check this article to get started with entity generation), it will auto-generate the corresponding tests for your entities. Execute cypress using this command :

src/YourApplication/ClientApp/node_modules/.bin/cypress open

Conclusion

Now you should be able to generate End-To-End tests though Cypress thanks to JHipster !
Feel free to contribute to JHipster.NET's GitHub repository and don't forget to put a star if you liked it.

Generate your first Xamarin application with JHipster.NET

Zenrac — Fri, 26 Feb 2021 10:31:05 +0000

Overview

JHipster is a famous generator allowing you to generate modern applications.

One of its official blueprints is called JHipster.NET. It allows to override the back-end part in asp.net core (instead of Java spring boot).

To take advantage of this blueprint, we will generate a modern application with a xamarin front-end. Meaning that both front-end and back-end will use C#.

Why Xamarin ?

With a C#-shared codebase, developers can use Xamarin tools to write native Android, iOS, and Windows apps with native user interfaces and share code across multiple platforms, including Windows, macOS, and Linux.

Choosing Xamarin allows to make a modern cross platform application with next to zero code duplication and waste of time.

Installation

You may find more information about how to generate your asp.net core application with JHipster.NET in this post.

To install JHipster generator, run this command :

npm install -g generator-jhipster

To install JHipster.NET blueprint, run the following command :

npm install -g generator-jhipster-dotnetcore

Move to any empy folder you want to, and generate your full-stack app by running this command :

jhipster -d --blueprints dotnetcore

If everything goes as expected, you should have few question to answer. For instance, first questions will ask you to choose a base name, and a C# namespace.

After few question, you will have to choose between one of the available fronts for your client.

Please note that Xamarin front is only available in debug mode. That's why the -d flag is mandatory.

Make sure to choose Xamarin :

Launch your back-end application

Before talking about how to use your Xamarin front-end, run the following command to launch your server and database :

dotnet run --verbosity normal --project ./src/YourAppName/YourAppName.csproj

Warning: Make sure to replace YouAppName with your actual real app name.

Moreover, if you have any difficulty, your generated application should contains a README.md that may help you quite a bit.

NuGet Requirements

Your generated Xamarin front-end application will require the following NuGet packages :

akavache >= 7.1.1
MvvmCross.Forms >= 7.1.1
System.ComponentModel.Annotations >= 5.0.0
System.Net.Http.Json >= 3.2.1
Xamarin.Forms >= 4.6.0
Xamarin.Essential >=1.5.3

Generated structure

Any generated Xamarin application is structured as follows :

client
├── Namespace.Client.Xamarin.Core     - Your core application
│   ├── Models
│   │   ├── Entities                  - Generated models
│   ├── Services
│   │   ├── Entities                  - Generated services
│   ├── ViewModels
│   │   ├── Entities                  - Generated viewmodels
│   ├── Views
│   │   ├── Entities                  - Generated views
├── Namespace.Client.Xamarin.Android  - Your Android application
│   ├── Resources          
│   │   ├── drawable                  - Contains your images
│   │   ├── Layout                    - Contains your layouts
│   ├── Properties
├── Namespace.Client.Xamarin.iOS      - Your iOS application   
│   ├── Resources                     - Contains your images
│   ├── Properties
├── Namespace.Client.Xamarin.Shared   - Shared code
│   ├── Constants                     - Contains shared constants

Entity generation

When creating a new entity in your database, your front-end is automatically updated to ensure a fully available management of all your entities.

Manual Entity Generation

To create an entity you can run the following command in your application folder:

jhipster entity <entity-name>

You will have to answer few more questions in order to decide if you want to add some relationship with other entities and if you want to add more fields to it.

JDL Entity Generation

You can also automaticaly generate many entities tanks to a JDL with the following command :

jhipster import-jdl my_file.jdl

A JDL (JHipster Domain Language) is a JHipster-specific domain language where you can describe all your applications, deployments, entities and their relationships in a single file (or more than one) with a user-friendly syntax.

You can create your JDL online on JDL Studio.

Conclusion

If you followed everything correctly, you should now have a modern Mvvm Xamarin Application with CRUD operations on all your entities.

Feel free to contribute to JHipster.NET's GitHub repository and don't forget to put a star if you liked it.