DEV Community: Anthony Ryckembusch

Introduction à Prometheus en .NET

Anthony Ryckembusch — Sun, 10 Sep 2023 05:10:12 +0000

Dans le monde des microservices et des applications distribuées, la surveillance des performances et des erreurs est cruciale. Prometheus est un système de surveillance et d'alerte open-source, et c'est une excellente solution pour collecter des métriques depuis vos applications .NET.

Dans cet article, je vais vous montrer comment intégrer Prometheus dans une application .NET.

Qu'est-ce que Prometheus ?

Prometheus est un système de surveillance et d'alerte open-source. Il recueille des métriques à partir des cibles configurées à intervalles donnés, les évalue par rapport à des règles, affiche les résultats et peut déclencher des alertes si certaines conditions sont remplies. Vous trouverez toutes les ressources sur le site prometheus.io.

Installation de Prometheus dans une application

Créons des mesures dans une application. Pour l'exemple je vais prendre un projet Blazor par défaut. Une fois le projet créé, il faut ajouter le package NuGet Prometheus. Il existe un package pour les applications Asp.NET, Prometheus-net.AspNetCore :

dotnet add package Prometheus-net.AspNetCore

Exemple d'utilisation

Création des métriques

Prometheus propose différents types de mesures :

Counters : Les compteurs augmentent seulement en valeur et sont remis à zéro lorsque le processus redémarre.
Gauges : Les jauges peuvent avoir n’importe quelle valeur numérique et changer arbitrairement.
Histogram : Les histogrammes suivent la taille et le nombre d’événements dans les compartiments. Cela permet un calcul agrégable des quantiles.
Summary : Les Summary suivent les tendances des événements au fil du temps (10 minutes par défaut).
durée d'une opération : ils peuvent être utilisées pour signaler la durée d’une opération (en secondes) à un summary, un histogramme, une jauge ou un compteur. Encapsulez l’opération que vous souhaitez mesurer dans un bloc d’utilisation.
suivi des opérations en cours : utiliser pour suivre le nombre d’opérations simultanées en cours. Encapsulez l’opération que vous souhaitez suivre dans un bloc. Par exemple : Gauge.TrackInProgress().
CountExceptions : Je pense que vous voyez à quoi ça peut servir ;) Il faut aller voir la doc pour avoir chaque particularités.

Je ne vais pas faire un exemple par chaque mesure, je vais faire un exemple avec un Counter.

Le Compteur

Dans cet exemple je vais créer ajouter un compteur et il comptabilisera chaque click du compteur du projet Blazor.

Le code de la vue avec notre compteur.

@page "/counter"
@using Prometheus  @* Ajout de l'importation ici *@

<PageTitle>Counter</PageTitle>

<h1>Counter</h1>

<p role="status">Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
        IncrementCounter.Inc();
    }

    private static readonly Counter IncrementCounter = Metrics.CreateCounter("counter_click_increments_total", "Nombre total de click.");
}

Examinons ça d'un peu plus près.

Je crée un nouveau compteur Counter IncrementCounter.
Je lui donne comme nom (ou comme "label") : counter_click_increments_total.
J'indique une description : "Nombre total de click.".
Ces informations se retrouveront dans l'exposition, voici l'exemple :

# HELP counter_click_increments_total Nombre total de click.
# TYPE counter_click_increments_total counter
counter_click_increments_total 5

C'est cette ligne : IncrementCounter.Inc(); qui fait l'incrément du compteur.

Bon, maintenant que nous avons une mesure, comment l'exposer au monde, et surtout que Prometheus puisse venir faire sa récolte.

Exposition des métriques

Pour exposer les métriques pour que Prometheus puisse les récupérer, il faut ajoutez dans Program.cs, ou dans la méthode Configure de la classe Startup (dépend de votre projet) :

app.UseRouting();

// Active la collecte des métriques HTTP
app.UseHttpMetrics(); 

// ... (du code, du code,...)

app.UseEndpoints(endpoints =>
{
    endpoints.MapMetrics(); // Expose les métriques à l'endpoint /metrics
    endpoints.MapControllers();
});

Petite explication.

app.UseHttpMetrics() : ce middleware ajoute plusieurs métriques par défaut. Pas obligatoire d'avoir ce middleware. Par exemple :

# HELP http_requests_received_total Provides the count of HTTP requests that have been processed by the ASP.NET Core pipeline.
# TYPE http_requests_received_total counter
http_requests_received_total{code="200",method="POST",controller="",action="",page="",endpoint="/_blazor/negotiate"} 1
http_requests_received_total{code="200",method="GET",controller="",action="",page="",endpoint="/_blazor/initializers/"} 1
http_requests_received_total{code="200",method="HEAD",controller="",action="",page="/_Host",endpoint=""} 1
http_requests_received_total{code="200",method="GET",controller="",action="",page="/_Host",endpoint=""} 1

Note : Il doit être placé après app.UseRouting().

endpoints.MapMetrics() : indique au serveur qu'il doit exposer un endpoint pour les mesures. Par défaut c'est /metrics. Maintenant que nous avons nos mesures, que nous les exposons, il ne reste plus qu'à installer et configurer notre serveur Prometheus.

Prometheus

Pour l'article, je vais utiliser l'installation de Prometheus en local pour Windows. Toutes les releases sont accessible sur prometheus.io/download.

Configuration de Prometheus

Il faut indiquer à Prometheus où trouver les métriques. Il faut éditer le fichier prometheus.yml et ajouter notre application à la liste des targets.

Voici le fichier de config complet :

# my global config
global:
  scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: "Prometheus"

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
      - targets: ["localhost:9090"]

  - job_name: 'blazorapp'
    scrape_interval: 30s
    scheme: https # Utilise le schéma HTTPS au lieu de HTTP par défaut
    static_configs:
      - targets: ['localhost:7116']

Maintenant, intéressons nous à notre application.

scrape_configs:
# ...autres jobs...

  - job_name: 'blazorapp'
    scrape_interval: 30s
    scheme: https # Utilise le schéma HTTPS au lieu de HTTP par défaut
    static_configs:
      - targets: ['localhost:7116']

Configuration de la tâche de scraping (job)

job_name : c'est le nom qui sert à regrouper un ensemble de cibles sous un même nom. Possible de scrap plusieurs cibles.
scheme : ce champ spécifie que le protocole HTTPS doit être utilisé pour le scraping. Par défaut, Prometheus utilise HTTP.
scrape_interval : L'intervalle à lequel Prometheus va "scraper" (récupérer) les métriques depuis les cibles définies. Dans ce cas, l'intervalle est de 30 secondes. Si cette option n'est pas spécifiée, l'intervalle par défaut global sera utilisé.

En complément, il est possible d'utiliser plusieurs formats pour indiquer cette durée. Voici quelques exemples :

Secondes : Utilisez s pour indiquer des secondes. Par exemple, scrape_interval: 15s définit un intervalle de scraping de 15 secondes.
Minutes : Utilisez m pour indiquer des minutes. Par exemple, scrape_interval: 5m définit un intervalle de scraping de 5 minutes.
Heures : Utilisez h pour indiquer des heures. Par exemple, scrape_interval: 2h définit un intervalle de scraping de 2 heures.
Jours : Utilisez d pour indiquer des jours, bien que ce ne soit généralement pas recommandé pour des opérations de scraping. Par exemple, scrape_interval: 1d définit un intervalle de scraping d'un jour.
Semaines : Utilisez w pour indiquer des semaines, bien que ce ne soit généralement pas recommandé pour des opérations de scraping. Par exemple, scrape_interval: 1w définit un intervalle de scraping d'une semaine.
Unité multiple : Vous pouvez également combiner plusieurs unités pour indiquer une durée précise. Par exemple, scrape_interval: 1h30m définit un intervalle de scraping d'une heure et trente minutes. Notez que si vous omettez l'unité, Prometheus supposera que la valeur est en millisecondes, ce qui n'est généralement pas ce que vous voulez pour un intervalle de scraping. Il est important de choisir un scrape_interval approprié en fonction des besoins de votre système et des métriques que vous collectez. Un intervalle trop court pourrait surcharger le système, tandis qu'un intervalle trop long pourrait manquer des informations importantes.

Configuration des cibles de scraping

static_configs : Cette section configure une liste statique de cibles pour le scraping. D'autres types de découverte de cibles (comme la découverte de services via Kubernetes, par exemple) peuvent également être configurés, mais ici une configuration statique est utilisée.
targets : ['localhost:7116']: Liste des cibles à scraper. Chaque cible est représentée par une chaîne de caractères sous la forme :. Dans l'exemple, je n'ai qu'une seule cible.

Un Graph ?

Le serveur Prometheus permet de créer des graphs sur les données récoltées. Il faut juste mettre le nom de notre label et Execute !

Conclusion

Vous avez maintenant une application .NET qui expose des métriques que Prometheus peut collecter. Bien sûr, cet exemple est très basique. Vous pouvez créer des compteurs, des jauges, des histogrammes et d'autres types de métriques pour suivre presque tout ce que vous pouvez imaginer dans votre application.

La surveillance est un aspect essentiel de tout système de production. Avec Prometheus et C#, vous avez les outils nécessaires pour construire un système de surveillance robuste qui peut évoluer avec vos besoins.

Optimiser les opérations SQL avec le traitement par lot

Anthony Ryckembusch — Sun, 03 Sep 2023 07:07:19 +0000

Lorsqu'il s'agit de gérer une application avec un grand nombre de connexions simultanées, il est essentiel de minimiser le temps pendant lequel la base de données est verrouillée. Les opérations courantes telles que les mises à jour (UPDATE) ou les suppressions (DELETE) peuvent entraîner un verrouillage prolongé des tables critiques, ce qui peut avoir un impact significatif sur les performances de l'application. Une solution à ce problème consiste à utiliser le traitement par lot en SQL.

J'ai appris cette technique avec une équipe formidable à qui je passe un Hello ;)

Qu'est-ce que le Traitement par Lot en SQL ?

C'est une technique SQL avancée visant à optimiser les opérations de base de données en traitant les données par lots plutôt en une seule fois. Cette approche permet de réduire le verrouillage des tables et d'améliorer les performances globales de l'application. J'explorerai le concept du traitement par lot en utilisant un exemple de script T-SQL.

Le Script de Traitement par Lot

Le script suivant est une base solide pour mettre en œuvre le traitement par lot en T-SQL. Il est composé de plusieurs étapes clés, chacune jouant un rôle essentiel dans le processus global.

-- Définir la taille du lot de traitement
DECLARE @batchToProcess INT = 500;

-- Table temporaire contenant les données à traiter
DROP TABLE IF EXISTS #LoopTable;
CREATE TABLE #LoopTable (
     IdInfos INT NOT NULL
);

-- Remplir la table temporaire avec les données à traiter
INSERT INTO #LoopTable (IdInfos)
SELECT what.Id
FROM dbo.UneTable what WITH (NOLOCK)
WHERE what.Statut = 123;

-- Table temporaire pour stocker les données du lot en cours
-- Assurez-vous que les types de données correspondent à ceux de #LoopTable
DROP TABLE IF EXISTS #CurrentAction;
CREATE TABLE #CurrentAction (
     IdInfos INT NOT NULL
);

-- Début de la boucle de traitement par lot
WHILE (EXISTS(SELECT TOP 1 1 FROM #LoopTable))
BEGIN
  -- Supprimer les premières lignes du lot et les stocker dans #CurrentAction
  DELETE TOP(@batchToProcess) FROM #LoopTable
  OUTPUT DELETED.* INTO #CurrentAction;

  -- Exécuter l'action souhaitée sur le lot de données (par exemple, une mise à jour)
  UPDATE act
  SET act.[Statut] = 456
  FROM dbo.UneAutreTable act WITH (NOLOCK)
  INNER JOIN #CurrentAction monLot
  ON monLot.IdInfos = act.Id;

  -- Effacer le lot de données traitées
  DELETE FROM #CurrentAction;

  -- Attendre un court laps de temps pour permettre le traitement d'autres requêtes
  WAITFOR DELAY '00:00:00.200';
END

Explication du Script

Définir la taille du lot (@batchToProcess) : Vous pouvez ajuster la taille du lot en fonction de vos besoins. Un lot plus grand peut améliorer l'efficacité, mais il peut également entraîner un verrouillage plus long de la table. Il s'agit d'un compromis à prendre en compte.
Création des tables temporaires : Deux tables temporaires, #LoopTable et #CurrentAction, sont créées pour stocker temporairement les données à traiter et les données du lot en cours, respectivement.
Remplir la table #LoopTable : Cette étape remplit la table temporaire #LoopTable avec les données à traiter. Dans cet exemple, nous sélectionnons les lignes de la table UneTable avec un statut spécifique (123).
Boucle de traitement par lot : La boucle WHILE continue d'exécuter tant qu'il reste des données dans #LoopTable.
Suppression des données du lot : Les premières lignes du lot, définies par @batchToProcess, sont supprimées de #LoopTable et stockées dans #CurrentAction. Cela permet d'isoler un lot de données pour traitement.
Exécution de l'action souhaitée : Dans cette section, vous pouvez spécifier l'action à effectuer sur le lot de données. Par exemple, nous utilisons une mise à jour (UPDATE) pour modifier le statut des lignes correspondantes dans UneAutreTable.
Effacement du lot : Une fois l'action effectuée, le lot de données traitées est effacé de #CurrentAction.
Attente courte : Une petite attente est introduite (WAITFOR DELAY) pour donner la possibilité au système de traiter d'autres requêtes pendant une courte période.

Conclusion

Le traitement par lot en SQL est une technique puissante pour optimiser les opérations de base de données, en particulier dans les applications à forte concurrence. En utilisant des tables temporaires et une approche par lots, vous pouvez minimiser les verrouillages de table prolongés et améliorer les performances globales de votre application. N'hésitez pas à personnaliser ce script en fonction de vos besoins spécifiques pour tirer le meilleur parti du traitement par lot.

Découverte de GRPC en .Net 6

Anthony Ryckembusch — Tue, 29 Aug 2023 15:20:30 +0000

Dans cet article je vais montrer comment mettre en place le framework gRPC dans une application (serveur et client).

Avec Visual Studio 2022 ou par la commande dotnet, il est possible de créer un projet gRPC.

Mais pour cet article je vais partir d’une application from scratch. Je veux aussi revenir à la base, faire toute la création du projet en ligne de commande. Nous sommes souvent très/trop aidés (moi le premier) avec des menus contextuels pour ajouter un package nuget, une référence à un projet, mais sait-on encore le faire sans ?

Tout le code source « final » se trouve sur GitHub.

Qu’est-ce que gRPC ?

gRPC est un framework initialement développé par Google en 2015. Je ne vais pas vous vendre du rêve en recopiant le site de grpc.io pour vous donner une bonne explication, je vous laisse aller la voir…

Les avantages

Je reprends les mots de la doc de Microsoft.

Les principaux avantages de gRPC sont :

Framework RPC léger, moderne et à haut niveau de performance.
Développement d’API « Contract-first », à l’aide de mémoires tampons de protocole par défaut, permettant des implémentations indépendantes du langage.
Outils disponibles pour de nombreux langages afin de générer des clients et serveurs fortement typés.
Prise en charge d’appels de streaming client, serveur et bidirectionnels.
Utilisation réduite du réseau avec sérialisation binaire Protobuf.

Ces avantages font de gRPC la solution idéale pour :

Les microservices légers où l’efficacité est essentielle.
Les systèmes polyglottes où plusieurs langages sont nécessaires au développement.
Les services en temps réel de point à point qui doivent gérer des demandes ou réponses de streaming.

Le projet

Ce que nous allons créer est un serveur Asp.Net Core qui sera possible d’interroger pour avoir la liste de tous les utilisateurs ou avoir un utilisateur par son id. Pour ne pas monter de base de données et rester dans quelque chose de simple, j’ai mis un fichier json contenant plus de 5000 fiches utilisateurs. Voici un exemple d’utilisateur :

{
    "_id": "61b6c9ceb0b039f7477bedef",
    "index": 0,
    "guid": "f7c10fe0-f887-4627-ac57-d332121664b9",
    "isActive": true,
    "balance": "$2,348.47",
    "picture": "http://placehold.it/32x32",
    "age": 27,
    "eyeColor": "green",
    "name": "Stephens Ferguson",
    "gender": "male",
    "company": "MOLTONIC",
    "email": "stephensferguson@moltonic.com",
    "phone": "+1 (976) 536-2883",
    "address": "294 Stillwell Avenue, Lowell, Oregon, 6643",
    "about": "Cupidatat veniam consectetur tempor est deserunt sint enim ullamco. Anim voluptate amet nulla commodo adipisicing ipsum minim aliqua dolore cillum aliqua adipisicing. Incididunt fugiat veniam officia velit cillum.\r\n",
    "registered": "2019-11-01T06:42:36 -01:00",
    "latitude": -71.063895,
    "longitude": 166.435462,
    "tags": [
      "fugiat",
      "esse",
      "velit",
      "duis",
      "magna",
      "ut",
      "voluptate"
    ],
    "friends": [
      {
        "id": 0,
        "name": "Polly Hull"
      },
      {
        "id": 1,
        "name": "Molina Livingston"
      },
      {
        "id": 2,
        "name": "Nikki Wong"
      }
    ],
    "greeting": "Hello, Stephens Ferguson! You have 5 unread messages.",
    "favoriteFruit": "apple"
  }

Création du serveur gRPC

Première partie, nous allons créer notre serveur.

Créer un répertoire pour accueillir le code source.

mkdir TutoGrpc
cd TutoGrpc

Je l’ai dit, on part de la base !

Une fois dans le répertoire, il faut créer notre fichier sln.

dotnet new sln

Le fichier sln prendra le nom du répertoire ou il se trouve (si pas d’option donnée).

Création de notre serveur Web.

dotnet new web -o ServerGrpc – doc dotnet new

Crée un nouveau projet avec le template web et avec l’argument -o (output) ServerGrpc.

web désigne un projet ASP.Net Core vide. Pour l’output cela donne le nom du projet et crée un répertoire du même nom.

Ajoutons ce projet dans notre fichier de solution.

dotnet sln add .\ServerGrpc\ – doc dotnet sln add

Nous allons avoir besoin des packages nuget pour gRPC, ajoutons-les à notre projet ServerGrpc.

cd ServerGrpc

dotnet add package Grpc.AspNetCore – doc dotnet add package

Je ne mets pas de nom de projet car je suis dans le répertoire du projet ou je veux ajouter les packages.

Grpc.AspNet.Core est un meta package, ça veut qu’il contienne plusieurs packages (pour la dernière version) :

Google.Protobuf (>= 3.18.0)
Grpc.AspNetCore.Server.ClientFactory (>= 2.41.0)
Grpc.Tools (>= 2.41.0)

Revenir en arrière cd.. pour être dans le répertoire où se trouve le fichier sln, et faire :

dotnet build. C’est pour être sûr que toutes les dépendances soient bien chargées.

Maintenant on peut ouvrir notre éditeur de code 😉

Du Code !

Partie Serveur

Nous avons notre projet Web tout vierge avec ces références à Grpc.AspNet.Core. Chargeons le fichier json en mémoire. Je crée un service IDataService qui va charger le fichier et faire la « gestion » sur les utilisateurs.

using System.Text.Json;

public class DataService : IDataService
{

    private List<User> AllUsers;


    public DataService()
    {
        AllUsers = LoadData()
                    .GetAwaiter()
                    .GetResult();
    }


    private async Task< /><User>> LoadData()
    {
        string pathFile = Path.Combine(AppContext.BaseDirectory, "Data", "Users.json");
        List<User> result = new List<User>();

        using (var stream = File.OpenRead(pathFile))
        {
            result = await JsonSerializer.DeserializeAsync< /><User>>(stream);
        }

        return result;
    }


    #region IDataService Implementation

    /// <see cref="IDataService.GetAllUser"></see>
    public User[] GetAllUser()
    {
        return AllUsers.ToArray();
    }

    /// <see cref="IDataService.GetCountUser"></see>
    public int GetCountUser()
    {
        return AllUsers.Count;
    }

    /// <see cref="IDataService.GetUser(string)"></see>
    public User GetUser(string id)
    {
        return AllUsers.FirstOrDefault(x => x._id == id);
    }

    #endregion
}

Juste pour info, voici l’entité User et Friend.

public class User
{
    public string _id { get; set; }
    public int index { get; set; }
    public string guid { get; set; }
    public bool isActive { get; set; }
    public string balance { get; set; }
    public string picture { get; set; }
    public int age { get; set; }
    public string eyeColor { get; set; }
    public string name { get; set; }
    public string gender { get; set; }
    public string company { get; set; }
    public string email { get; set; }
    public string phone { get; set; }
    public string address { get; set; }
    public string about { get; set; }
    public string registered { get; set; }
    public float latitude { get; set; }
    public float longitude { get; set; }
    public string[] tags { get; set; }
    public Friend[] friends { get; set; }
    public string greeting { get; set; }
    public string favoriteFruit { get; set; }
}

public class Friend
{
    public int id { get; set; }
    public string name { get; set; }
}

Il faut déclarer le service dans l’application (Program.cs) :

builder.Services.AddSingleton<IDataService, DataService="">();</IDataService,>

Maintenant il faut créer le services gRPC. Pour ce faire il faut créer un fichier Protobuf (.proto), de l’abréviation de Protocol Buffers. Protobuf a son propre langage, mais rien de compliqué. C’est avec ce fichier que les outils C# (Grpc.Tools) vont générer le code.

Créer un répertoire Protos dans le projet, et créer un fichier collectionusers.proto. Voici le code :

// déclare la version de la syntax
syntax = "proto3";

package collectionusers;
option csharp_namespace = "ServerGrpc";

// déclaration des services/ contrats.
service Utilisateurs {
    rpc GetUserById (UserIdRequest) returns (UserResponse);
    rpc GetCountUser(Empty) returns (CountUser);

    // prend un argument Empty
    rpc GetAll (Empty) returns (AllUsersResponse);
}

message Empty {};

message CountUser{
    int32 nombreUser = 1;
}

// Le message de requête contient l'ID de l'utilisateur.
message UserIdRequest {
    string idUser = 1;
}

message UserResponse {
    string id = 1; 
    int32 index = 2;
    string guid = 3;
    bool isActive = 4;
    string balance = 5;
    string picture = 6;
    int32 age = 7;
    string eyeColor = 8; 
    string name = 9;
    string gender = 10;
    string company = 11;
    string email = 12;
    string phone = 13;
    string address = 14;
    string about = 15;
    string registered = 16;
    float latitude = 17;
    float longitude = 18;
    repeated string tags = 19;
    repeated Friends friends = 20;
    string greeting = 21;
    string favoriteFruit = 22;
}

message Friends {
    int32 id = 1;
    string name = 2;
}

message AllUsersResponse {
    repeated UserResponse AllUsers = 1;
}

Attention : Pour que les outils puissent générer le code il faut ajouter dans le csproj l’emplacement du fichier proto.

<ItemGroup>
    <Protobuf Include="Protos\collectionusers.proto" GrpcServices="Server"></Protobuf>
</ItemGroup>

Il faut indiquer GrpcServices="Server" pour la partie serveur, et quand c’est la partie cliente il faut mettre ???? … Oui : Client. Non je ne me moque pas. Le code généré n’est pas le même c’est tout.

Maintenant examinons ça de plus près !

syntax = "proto3"; Indique la version de la syntax du fichier proto. La version actuelle est la 3. Voir la doc.
package collectionusers; On peut ajouter un spécificateur de package, c’est facultatif à un fichier .proto. C’est pour éviter les conflits de noms entre les types de messages de protocole. Voir la doc.
option csharp_namespace = "ServerGrpc"; Comme indiqué c’est une option, ça permet de donner un nom de namespace choisi pour la génération du code des messages, services,… je vais y revenir. Là j’override ce qui est mis dans package.
service Utilisateurs Déclaration d’un service qui va s’appeler Utilisateurs. Il contiendra les différentes méthodes que le service offrira via les rpc. Voir la doc pour les services.

rpc

Là ça devient intéressant. Comme dit plus haut, dans le service il faut déclarer les méthodes, et c’est avec le mot clé rpc. Je vais prendre un exemple :

rpc GetUserById (UserIdRequest) returns (UserResponse);

GetUserById : Nom de la méthode et il prend en paramètre un message UserIdRequest, et cette méthode retourne (returns) un autre message UserResponse.

message

Pour le C#, les messages sont l’objet principal de transfert de données dans Protobuf. Elles sont conceptuellement similaires aux classes .NET. Je vais prendre l’exemple avec :

message UserResponse {

string id = 1;

int32 index = 2;

....

repeated string tags = 19;

repeated Friends friends = 20;

.... }

A l’intérieur du message, il faut déclarer les propriétés ET son « ordre de passage ». Comme vous pouvez le voir, chaque champ de la définition du message a un numéro unique. Ces numéros sont utilisés pour identifier les champs dans le format binaire du message et ne doivent pas être modifiés une fois que le type de message est utilisé.

Mode Advanced : Notez que les numéros de champ compris entre 1 et 15 prennent un octet à coder, y compris le numéro de champ et le type de champ (vous pouvez en savoir plus à ce sujet dans Protocol Buffer Encoding). Les numéros de champ compris entre 16 et 2047 prennent deux octets. Vous devez donc réserver les numéros 1 à 15 pour les éléments de message très fréquents. N’oubliez pas de laisser de la place aux éléments fréquents qui pourraient être ajoutés à l’avenir. Voir la doc pour plus d’info sur la structure du message.

Attention : Le code est généré à la compilation du projet ! Donc avoir un projet compilable, quand vous ajoutez un service, une méthode ou un message.

Les types pour les propriétés

Comme protobuf a son « langage », il a sa manière de déclarer ses types. Dans l’exemple, j’ai fait exprès de choisir des types simples (string, int32,…) et des types plus complexes. Pour les types simples je vous laisse aller voir la doc Microsoft pour avoir la correspondance entre les types protobuf et les types .Net. Il y a aussi la doc google pour tous les langages.

Quand je dis type « complexe », c’est par exemple un tableau de string comme pour la propriété Tags. Pour déclarer un tableau/List, il faut utiliser le mot clé repeated.

Ensuite dans User, j’ai une propriété Friend[]. Pour les tableaux, il faut repeated, mais Friend n’est pas un type simple. Pas grave, il faut créer un nouveau message.

message Friends {
    int32 id = 1;
    string name = 2;
}

Même chose, définir les propriétés du message et l’ordre.

Pour infos : il est possible de déclarer un message dans un message, des types imbriqués. doc Google Nested type.

Pour une énumération voir la doc Google.

Implémentation du service gRPC

Une fois les services rpc déclarés, tous les message (request et response) déclarés et définis, il ne faut surtout pas oublier de compiler le projet, pour que les outils (Grpc.Tools) puissent générer le code.

Pour info: le code généré se trouve dans ...\ServerGrpc\obj\Debug\net6.0\Protos

Dans le répertoire Service, il faut ajouter une nouvelle class qui sera notre service qui va répondre aux différentes demandes. En voici le code.

using Grpc.Core;

namespace ServerGrpc.Services;

public class UtilisateursService : Utilisateurs.UtilisateursBase
{

    private IDataService dataSvc;

    public UtilisateursService(IDataService dataService)
    {
        dataSvc = dataService;
    }

    public override Task<CountUser> GetCountUser(Empty request, ServerCallContext context)
    {
        int nombre = dataSvc.GetCountUser();
        return Task.FromResult(new CountUser() { NombreUser = nombre});
    }

    public override Task<UserResponse> GetUserById(UserIdRequest request, ServerCallContext context)
    {
        // Récupération de l'utilisateur.
        User user = dataSvc.GetUser(request.IdUser);
        return Task.FromResult(CreateResponse(user));
    }

    public override Task<AllUsersResponse> GetAll(Empty request, ServerCallContext context)
    {
        var allUsers = dataSvc.GetAllUser();

        AllUsersResponse response = new AllUsersResponse();
        foreach (var user in allUsers)
        {
            response.AllUsers.Add(CreateResponse(user));
        }

        return Task.FromResult(response);
    }


    private UserResponse CreateResponse(User user)
    {
        // Création de UserSelected (correspondant à notre "message" gRPC)
        UserResponse userReponse = new UserResponse()
        {
            About = user.about,
            Address = user.address,
            Age = user.age,
            Balance = user.balance,
            Company = user.company,
            Email = user.email,
            EyeColor = user.eyeColor,
            FavoriteFruit = user.favoriteFruit,
            Gender = user.gender,
            Greeting = user.greeting,
            Guid = user.guid,
            Id = user._id,
            Index = user.index,
            IsActive = user.isActive,
            Latitude = user.latitude,
            Longitude = user.longitude,
            Name = user.name,
            Phone = user.phone,
            Picture = user.picture,
            Registered = user.registered,
        };

        // Pour les listes de string.
        foreach (var tag in user.tags)
        {
            userReponse.Tags.Add(tag);
        }

        // Pour les listes d'un autre objet.
        foreach (var amis in user.friends)
        {
            userReponse.Friends.Add(new Friends() { Id = amis.id, Name = amis.name });
        }

        return userReponse;
    }
}

Choses importantes :

public class UtilisateursService : Utilisateurs.UtilisateursBase

Il faut que notre class de service implémente la class généré du service proto. Le nom Utilisateurs correspond au nom du service proto : service Utilisateurs.

Nous retrouvons nos 3 méthodes correspondant à nos 3 déclarations rpc.

public override Task GetCountUser(Empty request, ServerCallContext context) public override Task GetUserById(UserIdRequest request, ServerCallContext context) public override Task GetAll(Empty request, ServerCallContext context)

Et enfin nous retrouvons tous les types de nos messages.

UserResponse, AllUsersResponse, UserIdRequest et Empty.

Il reste maintenant à configurer le serveur pour qu’il accepte des requêtes gRPC.

Dans Program.cs il faut ajouter le middleware de Grpc.

// Ajout du service Grpc
builder.Services.AddGrpc(options =>
{
    // Pour l'envoie de message sans limite de taille
    options.MaxSendMessageSize = null;
});

Il est possible de configurer le service gRPC. Pour cet exemple j’ai mis l’option MaxSendMessageSize à null.

Taille maximale du message, en octets, qui peut être envoyée à partir du serveur. Toute tentative d’envoi d’un message qui dépasse la taille de message maximale configurée entraîne une exception. Lorsque la valeur est null, la taille du message est illimitée.

Voir la Doc Microsoft pour avoir toutes les options.

Ensuite je veux configurer le serveur pour qu’il utilise le Http3 (HTTP/3 support in .NET 6)

string pathCertifFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Certif", "tutogrpc.pfx");
builder.WebHost.ConfigureKestrel((context, options) =>
{
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
        listenOptions.UseHttps(pathCertifFile, "PassCtrlAltSuppr");
    });
});

[...]

app.MapGrpcService<UtilisateursService>();

Je configure le serveur en « dur » pour qu’il écoute sur le port 5001, et qu’il utilise le protocole Http1AndHttp2AndHttp3.

Pour utiliser le HTTP3, il faut que la connexion soit sécurisée. J’ai exporté le certificat de développement. (Voir la fin de l’article, Note pour certificat, pour ajouter le certificat à votre machine, sinon Exception… (⌣̩̩́_⌣̩̩̀) ).

Pour voir la différence entre gRPC et un appel « classique » à un controller, j’ai créé ce controller.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace ServerGrpc.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TutoGrpcUsersController : ControllerBase
    {
        private IDataService DataService;

        public TutoGrpcUsersController(IDataService service)
        {
            DataService = service;
        }

        [HttpGet("count")]
        public int GetCountUser()
        {
            // requête :
            // https://localhost:5001/api/tutogrpcusers/count
            return DataService.GetCountUser();
        }

        [HttpGet("all")]
        public IEnumerable<User> GetUsers()
        {
            // requête :
            // https://localhost:5001/api/tutogrpcusers/all
            return DataService.GetAllUser();
        }

        [HttpGet("user")]
        public User GetUser(string id)
        {
            // requête :
            // https://localhost:5001/api/tutogrpcusers/user?id=61b6c9ceb0b039f7477bedef
            return DataService.GetUser(id);
        }
    }
}

Enfin je mets toute la configuration de Program.cs (gRPC + controller).

using Microsoft.AspNetCore.Server.Kestrel.Core;
using ServerGrpc.Services;
using System.Net;

var builder = WebApplication.CreateBuilder(args);

// Ajout du service Grpc
builder.Services.AddGrpc(options =>
{
    // Pour l'envoie de message sans limite de taille
    options.MaxSendMessageSize = null;
});
string pathCertifFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Certif", "tutogrpc.pfx");
builder.WebHost.ConfigureKestrel((context, options) =>
{
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
        listenOptions.UseHttps(pathCertifFile, "PassCtrlAltSuppr");
    });
});

builder.Services.AddSingleton<IDataService, DataService="">();

builder.Services.AddControllers();

var app = builder.Build();
app.UseRouting();

app.MapGrpcService<UtilisateursService>();
app.MapGet("/", () => "C'est pour l'article sur gRPC sur www.ctrl-alt-suppr.dev");

// Pour le controler
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

app.Run();</UtilisateursService></IDataService,>

Partie Client

Ajout d’une application cliente pour utiliser notre service gRPC.

A partir du répertoire de base, là où se trouve le fichier sln, faire :

dotnet new console -o ConsoleClient

Crée un nouveau projet Console. L’ajouter dans le sln.

dotnet sln add .\ConsoleClient

Ajout des packages gRPC dans notre client.

dotnet add .\ConsoleClient package Google.Protobuf dotnet add .\ConsoleClient package Grpc.Net.Client dotnet add .\ConsoleClient package Grpc.Tools

Ce n’est pas obligé d’être dans le répertoire du projet pour ajouter des packages.

Pour que le client puisse se connecter au service il faut qu’il connaisse aussi le fichier proto.

Note : Soit faire une copie du fichier proto du projet serveur dans le projet client, ce qui peut engendrer des problèmes s’il y a une différence entre les 2 versions. Sinon faire un projet que les 2 projets auront en référence.

Dans l’exemple j’ai copié le fichier proto.

J’ai fait ça c’est pour changer une ligne : option csharp_namespace = "ClientGrpc"; C’était pour montrer que le namespace est bien pris en compte lors de la génération de code.

Une fois le fichier proto copié, il faut ajouter la ligne dans le csproj en le déclarant comme GrpcServices="Client".

<ItemGroup>
    <Protobuf Include="Protos\collectionusers.proto" GrpcServices="Client"></Protobuf>
</ItemGroup>

Compiler la solution, pour que le code client soit généré.

Ajoutons le code pour se connecter au service.

using ClientGrpc;  // ---> namespace du fichier proto ;) 

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Utilisateurs.UtilisateursClient(channel);

Là c’est l’utilisation « simple », mais il est possible de forcer notre channel pour utiliser une connexion en HTTP3. Il faut que le serveur et le client soit compatible. Voici le code.

var http3Client = new HttpClient();
http3Client.DefaultRequestVersion = HttpVersion.Version30;
http3Client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact;

var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions
{
    MaxReceiveMessageSize = null,
    HttpClient = http3Client
});
var client = new Utilisateurs.UtilisateursClient(channel);

J’ai ajouté aussi une option pour que les messages reçus n’ont pas de limite de taille.

MaxReceiveMessageSize = null,

Il est possible d’ajouter des configurations côté client. Doc Microsoft.

Note : pour la différence entre les 2 temps, j’ai ajouté dans le temps de « récupération » via le controller le fait de convertir la chaine de string (json) en objet.

HttpClient httpClient = new HttpClient();
HttpResponseMessage resultController = await httpClient.GetAsync(BASE_ADDRESS + "/api/tutogrpcusers/all");
using (Stream reponse = await resultController.Content.ReadAsStreamAsync())
{
    var tousLesUtilisateurs = JsonSerializer.DeserializeAsync< /><User>>(reponse);
    $"Il y a {tousLesUtilisateurs.Result.Count} utilisateurs".ToConsoleResult();
}

Je l’ai ajouté car avec gGRPC une fois la réception terminée, nous travaillons déjà en objet.

AllUsersResponse allClients = await client.GetAllAsync(empty);

Pour conclure

C’est un poste de découverte, c’était histoire de dégrossir/démystifier se framework.

Note pour certificat

Pour que la machine ne lève pas d’exception entre votre machine et le serveur, il faut importer le certificat que j’ai exporté (Self-Signed Certificate). C’est un certificat pour « localhost », et vous avez surement déjà vos certificats, du coup il y aura un « désaccord » entre celui fourni dans l’application et ceux de votre machine.

Clic droit sur le .pfx.

Script en C#

Anthony Ryckembusch — Thu, 10 Aug 2023 12:57:23 +0000

Le script en C# ne date pas de hier (en 2011, pour les nostalgiques), et dans ce post je vais présenter l’outil : dotnet-script (site du projet).

Certains diront : « Ah mais non, il y a d’autres langages/technos pour faire du script, comme Powershell, Python ».

C’est vrai, mais il faut maitriser chaque techno/langage. Ensuite quand on maitrise une librairie (par exemple Newtonsoft.Json, **LA* librairie que tout développeur .NET a utilisé*), est-ce que je vais trouver la même chose en Python par exemple, et en combien de temps je vais pouvoir la maîtriser.

Bref, il y a du pour et du contre.

Installation

Pour le post, je suis en .NET 6, mais ça fonctionne aussi en .NET 5. Il faut utiliser la commande dotnet tool install, comme ci-dessous :

dotnet tool install -g dotnet-script

La dernière version à ce jour de l’article est la 1.4 pour le .NET 6 et 7.

Utilisation

L’outil permet de créer un script et un « environnement » dans le cas d’une utilisation avec Visual Studio Code et omnisharp (l’extension C#).

Faire la commande dans un répertoire :

dotnet-script init

Ça va générer 3 fichiers : launch.json, main.csx et omnisharp.json. L’extension des fichiers de script C# est le csx, afin de bien montrer la différence. Le fichier omnisharp.json contient des paramètres tels que le framework cible et autorise ou non les références de nuget.

{
  "script": {
    "enableScriptNuGetReferences": true,
    "defaultTargetFramework": "net6.0"
  }
}

Dans un script il n’y a pas de méthode Main. Commençons avec un simple Console.WriteLine.

Console.WriteLine("Le fameux Hello World !");
Console.WriteLine(">Appuyer sur une touche pour continuer.");
Console.ReadKey();

Pour exécuter un script, il faut faire la commande :

#dotnet-script nomDuFichier.csx // ou dotnet script (sans le "-")
dotnet-script main.csx

Référence à d’autres scripts

Tout mettre dans un script, ça peut faire beaucoup, et aussi en tant que dév nous aimons écrire une fois les choses, et surtout les réutiliser. Il est possible de charger un script, dans un script.

Il faut utiliser le mot clé : #load "nomdufichier.csx".

Prenons un exemple simple. Ajoutons dans le répertoire un nouveau script : ConsoleExtension.csx. En voici le code :

public static void Info(string message)
{
    ForegroundColor = ConsoleColor.White;
    Console.WriteLine(message);
}

public static void Result(string message)
{
    ForegroundColor = ConsoleColor.Green;
    Console.WriteLine(message);
}

public static void Title(string titre)
{
    ForegroundColor = ConsoleColor.White;
    Console.WriteLine("######## " + titre + " ########");
}

public static void Pause()
{
    Info(">Appuyer sur une touche pour continuer.");
    Console.ReadKey();
}

public static void SautDeLigne()
{
    Info(string.Empty);
}

J’ajouter la référence :

#load "ConsoleExtension.csx"

Ajoutons ça au script main.csx.

#load "ConsoleExtension.csx"

Console.WriteLine("Le fameux Hello World !");
Console.WriteLine(">Appuyer sur une touche pour continuer.");
Console.ReadKey();

// A partir d'ici, l'appel à Console se fait avec un autre script
Title("Utilisation d'un autre script");
Pause();
Info("Il est possible d'utiliser un autre fichier script en utilisant");
Result("#load \"nomdufichier.csx\"");
SautDeLigne();

Là j’ai utilisé des méthodes static, mais ça peut être des class pour définir des objets. Tout le champ des possibilités du C# est utilisable.

Utilisation de Nuget

C’est bien beau d’ajouter du code dans son script, mais bon je ne vais pas tout réinventer, je veux pouvoir utiliser des packages sur nuget… ou… de nuget ! (**sur* ou de ?*)

Et c’est possible ! C’est là que le script devient une machine de guerre. Pour utiliser un package il faut mettre dans le script :

#r "nuget: nomDuPackage, version"

On retrouve la commande sur le site de nuget pour un package.

Note : A chaque ajout d’un package avec la commande, il faut redémarrer l’extension Omnisharp (C#), pour que l’intellisense soit prise en charge pour l’ajout. (CTRL+SHIFT+P –> omnisharp)

Je vais prendre un exemple de package : AlienFruit.FluentConsole.AsciiArt. Il permet de faire du ACSII Art. Ajoutons tout ça dans le script main.csx, et je mets le script au complet.

#load "ConsoleExtension.csx"
#r "nuget: AlienFruit.FluentConsole.AsciiArt, 1.0.10"
using AlienFruit.FluentConsole.AsciiArt;
using AlienFruit.FluentConsole;

Console.WriteLine("Le fameux Hello World !");
Console.WriteLine(">Appuyer sur une touche pour continuer.");
Console.ReadKey();

// A partir d'ici, l'appel à Console se fait avec un autre script
Title("Utilisation d'un autre script");
Pause();
Info("Il est possible d'utiliser un autre fichier script en utilisant");
Result("#load \"nomdufichier.csx\"");
SautDeLigne();

Title("Utilisation d'un package Nuget");
Pause();

Info("Il faut utiliser la commande :");
Info("#r \"nuget: nomDuPackage, version\"");
SautDeLigne();
Pause();

Info("Exemple :");
FConsole.GetInstance().DrawDemo(DemoPicture.RainbowPukeSkull);
SautDeLigne();

Info("Voilà, à vos Script !");

Il faut que les instructions #load et #r soient TOUJOURS en haut du script.

Attention : Si dans Visual Studio Code après avoir ajouté un package nuget, VS vous met tout en erreur, j’ai eu la même chose. C’est un problème de version entre dotnet-script et Omnisharp (issue sur Github).

Pour cela il faut modifier le fichier de config de l’extension.

Il faut ajouter à la fin du fichier de config :

"omnisharp.path":"latest"

Omnisharp va se remettre à jour pour utiliser la dernière version du serveur. Faire un redémarrage de VS Code.

Petit bonus

Le petit bonus que je trouve cool, c’est qu’il est possible d’exécuter un script sans l’avoir en local (remote-scripts). Comme avec mon exemple :

dotnet script --no-cache https://raw.githubusercontent.com/AnthonyRyck/CodesPourDevTo/master/src/dotNetScript/ScriptViaWeb.csx

Voici à quoi ressemble le script

#load "nuget:ConsoleExtensionScript, 1.0.0"
#r "nuget: AlienFruit.FluentConsole.AsciiArt, 1.0.10"
using AlienFruit.FluentConsole.AsciiArt;
using AlienFruit.FluentConsole;

Info("Utilisation d'un script en \"Remote\" !");
Pause();

Info("Exemple :");
FConsole.GetInstance().DrawDemo(DemoPicture.Punisher);
SautDeLigne();

Info("Voilà, à vos Script !");
Pause();

Pour les scripts en remote, je conseille d’utiliser l’option --no-cache, ça force l’outil à reprendre le script à chaque fois, sinon il va rester bloqué sur son cache (oui ça sent le vécu…). S’il y a des modifications, comme il reste sur le cache, vous ne les verrez pas.

Ensuite avec un script qui n’est pas en local, vous ne pouvez pas faire de référence à d’autres scripts à distance (#load "nomFichier.csx"), SAUF quand ils sont exportés sur nuget.org. Il est possible de créer nos packages de script, et du coup il faut utiliser :

#load "nuget:packageName, version"
#load "nuget:ConsoleExtensionScript, 1.0.0"

Création d’un package nuget avec un csx

Pour l’exemple j’ai créé un package script ConsoleExtensionScript.

Comment procéder. Créer un fichier nuspec à la « racine ».

#nuget spec NomDuPackageVoulu
nuget spec ConsoleExtensionScript

Le fichier nuspec pour mon package ConsoleExtensionScript ressemble à ça.

<?xml version="1.0" encoding="utf-8"?>
<package>
  <metadata>
    <id>ConsoleExtensionScript</id>
    <version>1.0.0</version>
    <authors>Anthony Ryck</authors>
    <requireLicenseAcceptance>false</requireLicenseAcceptance>
    <license type="expression">MIT</license>
    <projectUrl>https://github.com/AnthonyRyck/CodesPourDevTo/tree/master/src/dotNetScript</projectUrl>
    <description>Pour montrer comment utiliser un package dans un script C#</description>
    <releaseNotes></releaseNotes>
    <copyright>Copyright Anthony Ryck 2022</copyright>
    <tags>csx</tags>
  </metadata>

  <files>
    <file src="contentFiles/csx/netstandard2.0/main.csx" target="contentFiles/csx/netstandard2.0/main.csx"></file>
  </files>
</package>

Ensuite le ou les fichiers csx doivent être mis en target dans un ordre de répertoire : /contentFiles/csx/netstandard2.0 et notre*/nos* fichier « main.csx ».

Je vous invite à lire le post : NuGet ContentFiles Demytified et la doc MS sur contentFiles, ils expliquent le pourquoi du nommage des répertoires.

Conclure

Depuis le .NET Core, il est possible de faire du scripting sur toutes les plateformes, pourquoi s’en privé ? C’est utilisé sur Azure : Azure Function.

Donc à vos scripts 😉

Passer du C# au Typescript

Anthony Ryckembusch — Mon, 07 Aug 2023 12:21:05 +0000

Quand on commence un nouveau langage, une nouvelle techno, nous cherchons toujours à nous rattacher à ce que nous connaissons. Quand je me suis mis à REACT/Angular avec du Typescript, et venant du monde .NET C#, j’ai commencé à faire les différences et les points communs entre ces langages.

Qu’est-ce que TypeScript ?

TypeScript est un langage open source développé et maintenu par Microsoft (github source), sous licence Apache 2. Il s’agit d’un « sur-ensemble » (super set) typé de Javascript qui se « compile » en JavaScript brut. Je mets des guillemets pour compiler, car ce n’est pas une compilation comme en C#, mais une transpilation (transpiler) du code TypeScript en code Javascript.

La commande pour « compiler » un fichier TypeScript en javascript est :

tsc nomDuFichier.ts.

La commande va générer un fichier du même nom, mais en js (javascript).

Mais alors pourquoi faire du TypeScript si c’est pour avoir du JavaScript en sortie ?

JavaScript est un langage dynamiquement typé. Cette caractéristique, qui facilite la déclaration des variables, peut, dans certains cas, entraîner des résultats inattendus. Le système de type statique en TypeScript permet de décrire la forme d’un objet, permet à TypeScript de valider le bon fonctionnement du code. Les règles sont plus strictes avec du typage fort, du coup les erreurs peuvent se voir pendant l’écriture du code, pas à la fin en test/prod.

Comparaisons

Je vais mettre des bouts de code pour comparer les 2 langages, dans le sens C# vers Typescript. Pour tester les bouts de code vous pouvez utiliser avec Visual Studio Code pour C# dotnet script (voir mon post sur le sujet) et pour TypeScript : deno.land, ou directement en ligne avec Playground.

Les variables

// C#
// Déclarer une variable
var unNombre = 12345;
var unBlabla = "Faire du blabla";
// équivaut à :
int unNombre = 12345;
string unBlabla = "Faire du blabla";

// Utilisation des constantes
const int unAutreNombre = 123456;
unAutreNombre = 123456; // ---> Exception

// TYPESCRIPT
// Déclarer une variable
let unNombre = 12345;
let unBlabla = "Faire du blabla";
// équivaut à :
let unNombre : number = 12345;
let unBlabla : String = "Faire du blabla";

// Utilisation des constantes
const unAutreNombre = 123456;
unAutreNombre = 123456; // ---> Exception

En C#, nous pouvons utiliser le mot clé var (doc Microsoft) pour déclarer une variable. C’est au moment de la compilation, que le compilateur va choisir le bon type pour la variable, mais nous pouvons aussi le dire de façon explicite, en indiquant directement le type. Personnellement je préfère, il n’y a pas ambiguïté. Pour les types primitifs sur TS.

En TS, c’est le mot clé let pour déclarer une variable, et n’a pas besoin d’être initialisée. Il y a aussi var, il est de portée sur la « function » et let est de portée sur le bloc.

Pour les 2 langages, const indique que c’est une constante.

Les conditions

if, else

// C#
int x = 10;
int y = 20;

if (x > y) 
{
    Console.WriteLine("x est plus grand que y.");
} 
else
{
    Console.WriteLine("x est inférieur ou égal à y.");
}

// TYPESCRIPT
let x: number = 10;
let y: number = 20;

if (x > y) 
{
    console.log('x est plus grand que y.');
} 
else
{
    console.log('x est inférieur ou égal à y.');
}

switch

// C#
short day = 4;

switch (day) {
    case 1:
        console.log("C'est lundi");
        break;
    case 2:
        console.log("C'est mardi");
        break;
    case 3:
        console.log("C'est mercredi");
        break;
    case 4:
        console.log("C'est jeudi");
        break;
    case 5:
        console.log("C'est vendredi");
        break;
    case 6:
        console.log("C'est samedi");
        break;
    case 7:
        console.log("C'est dimanche");
    default:
        console.log("Euhh... y a une coui(biiiip) dans le pâté");
        break;
}

// TYPESCRIPT
let day : number = 4;

switch (day) {
    case 1:
        console.log("C'est lundi");
        break;
    case 2:
        console.log("C'est mardi");
        break;
    case 3:
        console.log("C'est mercredi");
        break;
    case 4:
        console.log("C'est jeudi");
        break;
    case 5:
        console.log("C'est vendredi");
        break;
    case 6:
        console.log("C'est samedi");
        break;
    case 7:
        console.log("C'est dimanche");
    default:
        console.log("Euhh... y a une coui(biiiip) dans le pâté");
        break;
}

Les boucles

for

// C#
for (var i = 0; i < 3; i++) 
{
  Console.WriteLine("Numéro de i = " + i);
}

// TYPESCRIPT
for (let i = 0; i < 3; i++) 
{
  console.log ("Numéro de i = " + i);
}

foreach

// C#
int[] collection = {10,20,30,40};

foreach(var item in collection) {
  Console.WriteLine(item);
}

// TYPESCRIPT
let collection = [10, 20, 30, 40];

for (var item of collection) {
  console.log(item);
}

while

// C#
int i = 1;

while (i < 4) {
    Console.WriteLine( "J'en suis à :" + i );
    i++;
}

// TYPESCRIPT
let i: number = 1;

while (i < 4) {
    console.log( "J'en suis à :" + i )
    i++;
}

Les méthodes/functions

// C#
// Fonction sans paramètre ni retour.
public void Display()
{
   Console.WritleLine("Hello de C# !");
}

// TYPESCRIPT
// Fonction sans paramètre ni retour.
function display() 
{
    console.log("Hello de TypeScript!");
}

// pareil que
function display() : void 
{
    console.log("Hello de TypeScript!");
}

Le type retour d’une méthode en TS se met après les paramètres.

function NomDeLaFonction (nomParameter: type,...) : typeRetour { ... }

Si aucun retour, pas besoin d’ajouter le type de retour, mais nous pouvons le mettre ! Le retour void existe. Moi j’aime bien le mettre, c’est EXPLICITE !

// C#
public string Greet(string greeting, string name) 
{
    return greeting + " " + name + "!";
}

// Avec paramètre optionnel.
public string Greet(string greeting, string name = null)
{
    return greeting + " " + name + "!";
}

// Avec un paramètre par défaut
public string Greet(string name, string greeting = "Hello")
{
    return greeting + " " + name + "!";
}

// TYPESCRIPT
function Greet(greeting: string, name: string ) : string 
{
    return greeting + ' ' + name + '!';
}

// Avec paramètre optionnel.
function Greet(greeting: string, name?: string ) : string 
{
    return greeting + ' ' + name + '!';
}

// Avec un paramètre par défaut
function Greet(name: string, greeting: string = "Hello") : string 
{
    return greeting + ' ' + name + '!';
}

En TS il y a une différence entre un paramètre optionnel et un paramètre par défaut. Pour un paramètre optionnel name?: string, si le paramètre n’est pas indiqué lors de l’appel à la function, le type sera undefined.

Class

La doc sur les class en Typescript (doc sur Typescript.org). Je vais essayer de mettre le plus de chose dans le bout de code.

// C#
public class Person
{
    protected readonly string name;
    // Pour montrer les niveaux de visibilité
    public int age;
    string numSecu; // --> défaut en private

    public Person(string nom, int age, string secu)
    {
        name = nom;
        age = age;
        numSecu = secu;
    }
}

public class Habitant : Person
{
    public string Adresse { get; set; }

    // Juste pour montrer en "Full"
    private string _autreAdresse;

    public string AutreAdresse
    {
        get { return _autreAdresse; }
        set { _autreAdresse = value; }
    }

    public Habitant(string nom, int age, string secu, string adress)
        : base(nom, age, secu) // Appel au constructeur de Person
    {
        Adresse = adress;
    }

    public void WhoAreYou()
    {
        Console.WriteLine($"Je suis " + this.name + " et j'habite au " + this.Adresse);
    }
}

// TYPESCRIPT
class Person 
{
    // Fields
    protected readonly name: string;
    // Pour montrer les niveaux de visibilité
    age: number; // --> défaut en public
    private numSecu: string;

    constructor(nom: string, age: number, secu: string) 
    {
      this.name = nom;
      this.age = age;
      this.numSecu = secu;
    }
}

class Habitant extends Person 
{

    // Field
    _adresse: string;

    // Getter et Setter
    get adresse() {
        return this._adresse;
    }
    set adresse(value) {
        this._adresse = value;
    }

    // Constructeur
    constructor(nom: string, age: number, secu: string, adress: string) 
    {
        // super : pour faire appel au constructeur de Person.
        super(nom, age, secu);
        this._adresse = adress;
    }

    public whoAreYou () : void 
    {
        console.log("Je suis " + this.name + " et j'habite au " + this.adresse)
    }
}

// Utilisation de la class
let hab : Habitant = new Habitant("Jean", 25, "15151548", "la bas");
hab.whoAreYou();

En C# ou TS, il y a un quelques différences, mais ça reste très proche.

Interface

Bon là c’est la grosse différence que j’ai trouvé entre C# et TS.

Interface en tant que Type

// TYPESCRIPT
interface Person {
    name: string;
    age: number;
}

let quiEstce: Person = { name:"Jean", age:25 };

C’est une entité, un simple objet POCO en C#. Juste des propriétés sans méthode pour ajouter du « comportement ».

Interface « classique » par rapport au C

// C#
interface Person 
{
    name: string;
    age: number;

    // Déclare une fonction
    getAnneeNaissance(anneeEnCours: Date) : number;
}

On peut déclarer une interface, avec des propriétés et des méthodes qui seront implémentés dans une class.

Interface comme type de fonction

L’interface TypeScript est également utilisée pour définir un type de fonction. Cela garantit la signature de la fonction.

// TYPESCRIPT
// Interface comme type de fonction
interface Person 
{
    name: string;
    age: number;
}

createPerson(name: string, age: number) : void 
{
    // code de création
    Person     
}

let unePersonne: Person = createPerson;

En TS : Les interfaces fournissent une structure aux objets. Elles peuvent hériter d’autres interfaces et des class.

En C# : Les interfaces sont des contrats pour les classes à implémenter. Elles peuvent seulement hériter d’autres interfaces.

Et le LINQ dans tout ça ?

Une des grandes forces de C# c’est LINQ, alors est-ce qu’il y a la même chose ?

Eh bien oui !

Where

// C#
Person jean = new Person() { Name="Jean", Age=42, Sexe="homme"};
Person gisel = new Person() { Name="Giselle",Age=52,Sexe="femme"};
Person marcel = new Person() { Name="Marcel", Age=25,Sexe="homme"};
Person marion = new Person() { Name="Marion", Age=28, Sexe="femme"};
Person[] allPeople = new Person[] { jean,gisel, marcel, marion };

var selectedPerson = allPeople.Where(x => x.Sexe == "homme");

foreach (var person in selectedPerson)
{
    Console.WriteLine(person.Name);
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Sexe { get; set; }
}

// TYPESCRIPT
interface Person{
    name: string;
    age: number;
    sexe: string;
}

let allPeople : Person[] = [{name:"Jean", age: 42, sexe:"homme"},
                            {name:"Marcel", age: 25, sexe:"homme"},
                            {name:"Giselle", age:52, sexe:"femme"},
                            {name:"Marion", age:28, sexe:"femme"}]

// utiliser "filter"
let selectedPerson = allPeople.filter(x => x.sexe === 'homme');

for(let person of selectedPerson)
{
    console.log(person.name);
}

Any

// C#
bool found = allPeople.Any(x => x.age == 25);

// TYPESCRIPT
boolean found = (allPeople.findIndex(x => x.age === 25) >= 0);

FirstOrDefault

// C#
var person = allPeople.FirstOrDefault(x => x.Name == "Jean");

// TYPESCRIPT
let person = allPeople.find(x => x.name === "Jean");

Conclure

Je n’ai pas tout mis car il y a des particularités dans chaque langage, et c’est vraiment dans une utilisation quotidienne et sur du long terme qu’on maitrise un langage, mais nous pouvons voir que les 2 langages se rapproche beaucoup.

JSON avec .Net

Anthony Ryckembusch — Mon, 07 Aug 2023 12:15:41 +0000

En lisant le post « Try the new System.Text.Json source generator« , je me suis rendu compte que j’utilisais que très peu l’espace de noms System.Text.Json du .Net. Des années a utiliser Newtonsoft.Json, que je ne pensais plus à tester ou utiliser autre chose. Aaahhh la routine, l’ennemi du changement.

Microsoft a livré cet espace de noms System.Text.Json avec le .Net Core 3.0 en 2019. Le pourquoi cet espace de noms était la performance et la sécurité. Microsoft a essayé d’empaqueter Newtonsoft.Json dans .Net, ils ont eu quelques difficultés. Microsoft souhaitait également supprimer la dépendance Newtonsoft.Json d’ASP.Net Core 3.0. Voilà pour la petite histoire.

J’ai fait un projet de test pour montrer cet espace de noms. Le projet se trouve sur GitHub, dans le répertoire dotNet6, projet TutoJson.

Lire un JSON

Que la source soit via une requête Web ou d’un fichier JSON, il faut « Deserializer » le JSON en objet. Pour l’exemple j’ai généré un fichier JSON avec le site : JSON Generator. J’ai crée des « Personnes ». En voici un exemple de personne.

{
    "id": "70f05566-1386-425d-bec3-d20b9c8e88fa",
    "index": 0,
    "isActive": true,
    "age": 40,
    "name": "Florence Wade",
    "gender": "female",
    "company": "VICON",
    "email": "florencewade@vicon.com",
    "phone": "+1 (942) 437-2165",
    "address": "405 Times Placez, Motley, Nevada, 9643",
    "about": "Id reprehenderit aute laborum do eiusmod qui reprehenderit dolore. Proident reprehenderit duis do duis minim commodo aute id. Anim incididunt in irure fugiat ipsum ex. Aliqua officia sunt excepteur proident tempor ex.\r\n",
    "registered": "2021-08-18T04:16:38 -02:00",
    "latitude": 8.848137,
    "longitude": 73.653237,
    "friends": [
      {
        "id": 0,
        "name": "Johnston Zamora"
      },
      {
        "id": 1,
        "name": "Clarke Blair"
      },
      {
        "id": 2,
        "name": "Lindsey Chandler"
      }
    ],
    "greeting": "Hello, Florence Wade! You have 2 unread messages.",
    "favoriteFruit": "apple"
}

Voilà un bout de code, pour passer d’une forme « string » en objet.

"######## Début de l'application Démo ########".ToConsoleInfo();
"######## pour JSON en .Net 6         ########".ToConsoleInfo();
"#:> Appuyer sur une touche pour commencer.".ToConsoleInfo();
ReadKey();

"######## LECTURE d'un JSON à partir d'un fichier ###########".ToConsoleInfo();
"#:> Appuyer sur une touche pour commencer.".ToConsoleInfo();
ReadKey();
WriteLine();

string pathFile = Path.Combine(AppContext.BaseDirectory, "Files", "personnes.json");
// En utilisant un stream.
using(var stream = File.OpenRead(pathFile))
{
    List<Personne> personnes = await JsonSerializer.DeserializeAsync< /><Personne>>(stream);
    $"Il y a {personnes.Count} personnes dans le fichier.".ToConsoleResult();
}

Il faut utiliser :

await JsonSerializer.DeserializeAsync<List<Personne>>(stream);

Doc Microsoft pour JsonSerializer.DeserializeAsync.

A partir de là, nous pouvons travailler avec des objets Personne, mais moi je veux faire de la « manipulation » sur le JSON, sans passer pour nos objets « métiers ».

JsonObject / JsonNode

Chargement en mémoire.

JsonNode jsonNodePerson;
using (var stream = File.OpenRead(pathFile))
{
    jsonNodePerson = JsonObject.Parse(stream);
}
//NOTE : Possible de passer par un string.
//string contentString = File.ReadAllText(pathFile, Encoding.UTF8);

Faisons quelques requêtes. Trouver le nom d’une personne :

"Pour avoir le nom de la 2eme personne dans le fichier".ToConsoleInfo();
string nomPersonne = jsonNodePerson[1]["name"].GetValue<string>();
$"Nom de la 2eme personne {nomPersonne}".ToConsoleResult();

// avoir la valeur de la latitude.
double latitude = jsonNodePerson[1]["latitude"].GetValue<double>();
$"Latitude renseigné : {latitude}".ToConsoleResult();

Il est possible de « naviguer » dans l’arbre du JSON. Et s’il y a un Array dans une propriété, pareil on peut naviguer dedans.

La propriété friends est un Array.

"Parcours dans les amis :".ToConsoleInfo();
var jsonFriend = jsonNodePerson[1]["friends"][2].ToJsonString();
$"Affiche un amis de la liste en JSON : {jsonFriend}".ToConsoleResult();

"Parcours dans un ami particulier :".ToConsoleInfo();
string nomAmi = jsonNodePerson[1]["friends"][2]["name"].GetValue<string>();
$"Nom de l'amis : {nomAmi}".ToConsoleResult();

J’ai utiliser la méthode ToJsonString() qui : (je cite la doc) « Convertit l’instance actuelle en chaîne au format JSON ».

Bon maintenant je veux ajouter une nouvelle propriété à toutes les personnes, mais toujours sans passer par un objet Personne.

Se sera la propriété preference, et ils auront tous la même valeur : « .Net 6 le meilleur ».

"Ajout d'une nouvelle propriété pour tout le monde : preference, avec sa valeur".ToConsoleInfo();
"#:> Appuyer sur une touche pour commencer.".ToConsoleInfo();
ReadKey();
JsonArray jsonArray = jsonNodePerson.AsArray();
$"Combien d'élément dans JsonArray : {jsonArray.Count}".ToConsoleResult();
WriteLine();
"Nous allons ajouter une nouvelle propriété dans le JSON".ToConsoleInfo();
for (int i = 0; i < jsonArray.Count; i++)
{
    jsonArray[i]["preference"] = ".Net 6 le meilleur";
}

"Vérification sur une personnne au hasard :".ToConsoleInfo();
Random random = new Random();
jsonArray[random.Next(0, jsonArray.Count)].ToString().ToConsoleResult();

J’indique que jsonNodePerson est un type JsonArray, ce qui me permet de boucler dessus :

JsonArray jsonArray = jsonNodePerson.AsArray();

Et pour chaque élément, j’ajoute la nouvelle propriété :

jsonArray[i]["preference"] = ".Net 6 le meilleur";

On peut dire que c’est très facile d’ajouter une propriété.

Même chose dans le sens inverse, je veux enlever la propriété gender.

"Maintenant il faut enlever le genre, propriété gender".ToConsoleInfo();
"#:> Appuyer sur une touche pour commencer.".ToConsoleInfo();
ReadKey();
for (int i = 0; i < jsonArray.Count; i++)
{
    jsonArray[i].AsObject().Remove("gender");
}
"Vérification sur une personnne au hasard :".ToConsoleInfo();
jsonArray[random.Next(0, jsonArray.Count)].ToString().ToConsoleResult();

JsonDocument

Il est possible de charger un JSON dans un JsonDocument.

2 points d’attention sur JsonDocument :

Fournit un mécanisme permettant d’examiner le contenu structurel d’une valeur JSON sans instancier automatiquement des valeurs de données.Microsoft

Source : Microsoft

Ce qui veut dire un gain sur l’espace mémoire.

Et l’autre point, qui n’est pas des moindres :

Cette classe utilise les ressources de la mémoire regroupée pour réduire l’impact du garbage collector (GC) dans les scénarios à forte utilisation.
Si vous ne parvenez pas à supprimer correctement cet objet, la mémoire ne sera pas retournée au pool, ce qui augmentera l’impact GC sur les différentes parties de l’infrastructure.Microsoft

Source : Microsoft

Il faut utiliser les using(JsonDocument ....), et ne pas faire le fifou.

Avec JsonDocument ça nous permet de faire des requêtes LinQ.

"#### Utilisation avec JsonDocument ####".ToConsoleInfo();
"#:> Appuyer sur une touche pour commencer.".ToConsoleInfo();
ReadKey();
"Récupération de tous les noms".ToConsoleInfo();

using (var stream = File.OpenRead(pathFile))
using (JsonDocument document = JsonDocument.Parse(stream))
{
    JsonElement root = document.RootElement;
    var namesPersonne = root.EnumerateArray()
                            .Select(x => x.GetProperty("name")
                                        .GetString())
                            .ToList();

    $"Il y a {namesPersonne.Count} noms".ToConsoleResult();

    foreach (var name in namesPersonne.Take(100 .. 110))
    {
        $"- Nom : {name}".ToConsoleResult();
    }

    var personnesSup35ans = root.EnumerateArray()
                                .Where(x => x.GetProperty("age").GetInt32() > 35)
                                .Select(x => new
                                {
                                    Nom = x.GetProperty("name").GetString(),
                                    Age = x.GetProperty("age").GetInt32()
                                }).ToList();

    $"Il y a {personnesSup35ans.Count} personnes qui ont plus de 35 ans".ToConsoleResult();
    foreach (var person in personnesSup35ans)
    {
        $"- Nom : {person.Nom} - Age : {person.Age}.".ToConsoleResult();
    }
}

Note : J’ai utilisé namesPersonne.Take(100..110), c’est une des nouveautés du C# 10. Permet de prendre les éléments entre l’index 100 et 110. Doc Microsoft sur le Take et le Range.

C# 10 est plein de petites nouveautés, que je vous invite à lire sur Announcing .Net 6.

Serialization

Maintenant nous allons « Serializer » une liste d’objet Incident. Il n’y a que 2 propriétés dans cet objet, Id et Titre.

List<Incident> incidentsObject = new List<Incident>();
for (int i = 0; i <= 10; i++)
{
    incidentsObject.Add(new Incident() { Id = i, Titre = $"Problème num {i}" });
}

string contentInString = JsonSerializer.Serialize(incidentsObject);

contentInString.ToConsoleResult();
WriteLine();

"Raahhh beurk, ce n'est pas indenté".ToConsoleInfo();

Voilà la sortie.

[{"Id":0,"Titre":"Probl\u00E8me num 0"},{"Id":1,"Titre":"Probl\u00E8me num 1"},{"Id":2,"Titre":"Probl\u00E8me num 2"},{"Id":3,"Titre":"Probl\u00E8me num 3"},{"Id":4,"Titre":"Probl\u00E8me num 4"},{"Id":5,"Titre":"Probl\u00E8me num 5"},{"Id":6,"Titre":"Probl\u00E8me num 6"},{"Id":7,"Titre":"Probl\u00E8me num 7"},{"Id":8,"Titre":"Probl\u00E8me num 8"},{"Id":9,"Titre":"Probl\u00E8me num 9"},{"Id":10,"Titre":"Probl\u00E8me num 10"}]

Quand vous exécuterez le code, le JSON est tout en ligne par défaut, ce qui est bien pour le stockage, envoie sur le Web, mais incompréhensible quand il faut l’ouvrir. Il est possible d’indiquer au moment de la sérialisation d’indenté le JSON avec JsonSerializerOptions.

JsonSerializerOptions options = new() { WriteIndented = true };
contentInString = JsonSerializer.Serialize(incidentsObject, options);

{
  "description": "Liste des incidents pour un probl\u00E8me",
  "incidents": [
    {
      "id": 1,
      "titre": "Probl\u00E8me num\u00E9ro 1."
    },
    {
      "id": 2,
      "titre": "Probl\u00E8me num\u00E9ro 2."
    },
    {
      "id": 3,
      "titre": "Probl\u00E8me num\u00E9ro 3."
    },
    {
      "id": 4,
      "titre": "Probl\u00E8me num\u00E9ro 4."
    },
    {
      "id": 5,
      "titre": "Probl\u00E8me num\u00E9ro 5."
    },
    {
      "id": 6,
      "titre": "Probl\u00E8me num\u00E9ro 6."
    },
    {
      "id": 7,
      "titre": "Probl\u00E8me num\u00E9ro 7."
    },
    {
      "id": 8,
      "titre": "Probl\u00E8me num\u00E9ro 8."
    },
    {
      "id": 9,
      "titre": "Probl\u00E8me num\u00E9ro 9."
    },
    {
      "id": 10,
      "titre": "Probl\u00E8me num\u00E9ro 10."
    }
  ]
}

Bon, le JSON est indenté, mais les caractères spéciaux ne sont pas reconnus. Pour remédier à ça il faut encore ajouter une option.

JsonSerializerOptions optionSpecial = new()
{
    Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
    WriteIndented = true
};

contentInString = JsonSerializer.Serialize(incidentsObject, optionSpecial);

Avec UnicodeRanges, il est possible de choisir l’encodage des caractères. –> Doc UnicodeRanges.

Je fais court sur cette partie, beaucoup d’explications pour la sérialisation sont sur le post :

« Try the new System.Text.Json source generator » que j’ai parlé au début.

Création d’un JSON à la « mano »

Bon maintenant, je veux pouvoir créer un JSON de toute pièce, sans objet !

Création du JSON Incident.

JsonArray incidents = new JsonArray();
for (int id = 1; id <= 10; id++)
{
    JsonObject nouveauIncident = new JsonObject
    { 
        ["id"] = id, 
        ["titre"] = $"Problème numéro {id}." 
    };
    incidents.Add(nouveauIncident);
}

// Ajout de tous les incidents dans 
JsonObject jsonIncidents = new JsonObject();
jsonIncidents.Add("description", "Liste des incidents pour un problème");
jsonIncidents.Add("incidents", incidents);

Dans cette exemple, j’ai voulu montrer les 2 manières de créer une structure JSON :

en utilisant les [ ] dans l’initialisation d’un nouveau JsonObject
ou en passant pour la méthode .Add("propertyName", Value)

{
  "description": "Liste des incidents pour un problème",
  "incidents": [
    {
      "id": 1,
      "titre": "Problème numéro 1."
    },
    {
      "id": 2,
      "titre": "Problème numéro 2."
    },
    {
      "id": 3,
      "titre": "Problème numéro 3."
    }
  ]
}

Comme nous travaillons avec des objets JsonObject, JsonNode, JsonArray, nous pouvons faire toutes les manipulations du début du post.

Pour ce qui est de la performance, il existe plusieurs posts sur le Web mais sans trop vous « spoiler », c’est le meilleur !

EntityFrameworkCore Code Firsts

Anthony Ryckembusch — Mon, 07 Aug 2023 12:04:31 +0000

Dans mon premier post sur EF Core, j’ai montré comment installer EF Core en ligne de commande et faire du Database First (générer du code à partir d’une base de données). Dans ce post, je vais montrer comment générer une base de données à partir du code, c’est le Code First. Le code source du projet d’exemple est sur GitHub.

Préparation

Je vais prendre un exemple simple de clients qui ont passés des commandes. Voilà à quoi la base doit ressembler :

Création du projet.

mkdir TutoEfCoreCodeFirst
cd  TutoEfCoreCodeFirst
dotnet new sln   # Ajout du fichier sln
mkdir WebApiCodeFirst  # répertoire pour le projet
cd WebApiCodeFirst  
dotnet new webapi --no-https --use-minimal-apis
cd ..
dotnet sln add .\WebApiCodeFirst\ # ajout du projet dans le sln

La commande nous crée notre projet Web API avec le minimum vital.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

var summaries = new[]
{
    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};

app.MapGet("/weatherforecast", () =>
{
    var forecast =  Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateTime.Now.AddDays(index),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast");

app.Run();

record WeatherForecast(DateTime Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

J’enlève tout ce qui est inutile pour le post et il nous reste :

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.Run();

Pour que le code crée les tables dans une base de données, il faut une base. Pour l’exemple je vais prendre SQLite. Ajoutons le nécessaire au projet.

dotnet add package Microsoft.EntityFrameworkCore.Sqlite

Install-Package Microsoft.EntityFrameworkCore.Sqlite

Création des models

Maintenant il faut créer nos modèles. Avant de les créer je vais ajouter un fichier GlobalUsings.cs (au cas vous ne connaissez pas, un bon post pour expliquer global using)

J’ajouterai d’autres using.

global using System.ComponentModel.DataAnnotations;
global using System.ComponentModel.DataAnnotations.Schema;

Les modèles liés au « Client ».

namespace WebApiCodeFirst.Models
{
    public class Client
    {
        [Key]
        public string Id { get; set; }

        [Required(ErrorMessage = "Un prénom est obligatoire")]
        public string Prenom { get; set; }

        [Required(ErrorMessage = "Un nom est obligatoire")]
        public string Nom { get; set; }

        [Required(ErrorMessage = "Un age est obligatoire")]
        public int Age { get; set; }

        public Adresse Adresse { get; set; }

        public ICollection<Telephone> Telephones { get; set; }

        public ICollection<Commande> Commandes { get; set; }
    }
}

namespace WebApiCodeFirst.Models
{
    public class Adresse
    {
        [Key]
        public string Id { get; set; }

        public string Numero { get; set; }
        public string Rue { get; set; }
        public string Ville { get; set; }

        [ForeignKey("ClientId")]
        public string ClientId { get; set; }
    }
}

namespace WebApiCodeFirst.Models
{
    public class Telephone
    {
        [Key]
        public string Number { get; set; }

        public string Type { get; set; }

        [ForeignKey("ClientId")]
        public string ClientId { get; set; }
    }
}

Et les modèles liés à une « Commande ».

namespace WebApiCodeFirst.Models
{
    public class Commande
    {
        [Key]
        public string IdCmd { get; set; }

        [ForeignKey("ClientId")]
        public string ClientId { get; set; }

        public ICollection<Panier> Panier { get; set; }
    }
}

namespace WebApiCodeFirst.Models
{
    public class Panier
    {
        [Key]
        public Guid IdPanier { get; set; }

        public int IdItem { get; set; }
        public int Quantite { get; set; }

        [ForeignKey("CommandeIdCmd")]
        public string CommandeIdCmd { get; set; }
    }
}

Comment EF Core gère les colonnes et fait les relations

Nous pouvons voir qu’il y a des attributs qui sont mis sur certaines propriétés :

Key (doc sur MS) : Indique la clé primaire, « une entité de manière unique« .

ForeignKey (doc sur MS) : Indique la clé étrangère.

Required : Indique que ce sera une valeur NON NULL en base.

J’aurai pu ajouter aussi l’attribut :

[StringLength(50, ErrorMessage = "Le nom est trop long, 50 caractères max")]

pour spécifier à la base une longueur max de caractère pour cette colonne.

Pour avoir une liste des attributs possible sur entityframeworktutorial.net, entityframework.net et bien sûr la référence docs.microsoft.com.

Avec les attributs, nous pouvons indiquer comment les colonnes seront gérées (primary key, not null, …), mais comment indiquer les relations entre les tables. Prenons l’exemple entre l’entité Client et Telephone.

Telephone indique qu’il a une propriété de clé étrangère qui s’appelle ClientId.

[ForeignKey("ClientId")]
public string ClientId { get; set; }

En mettant juste ça, il n’y aura pas de lien entre les tables, il faut aussi indiquer à l’entité Client une propriété :

public ICollection<Telephone> Telephones { get; set; }</Telephone>

Attention : il y a une convention d’écriture entre les propriétés pour que EF puisse faire la bonne liaison entre les tables, sinon il peut soit prendre la mauvaise propriété, soit carrément créer une nouvelle colonne pour faire la FK. Le mieux est de mettre les mêmes noms de propriété dans chaque entité.

Nous avons tous les modèles, maintenant il faut indiquer à l’application comment construire la base de données.

Création du Context

Il n’y a pas besoin d’installer le package Microsoft.EntityFrameworkCore, car Microsoft.EntityFrameworkCore.Sqlite a comme dépendance :

Microsoft.EntityFrameworkCore.Sqlite.Core qui lui a comme dépendance :

Microsoft.EntityFrameworkCore.Relational qui dépend de :

Microsoft.EntityFrameworkCore.

Ajouter un répertoire Data et la class ApplicationDbContext

using Microsoft.EntityFrameworkCore;

namespace WebApiCodeFirst.Data
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions options) 
            : base(options)
        {
        }

        public DbSet<Telephone> Telephones { get; set; }
        public DbSet<Adresse> Adresses { get; set; }
        public DbSet<Client> Clients { get; set; }
        public DbSet<Panier> Paniers { get; set; }
        public DbSet<Commande> Commandes { get; set; }
    }
}

Définition de DbContext sur la doc MS, juste en prenant les premiers mots : « Une instance DbContext représente une session avec la base de données et peut être utilisée pour interroger et enregistrer des instances de vos entités«

Définition du type DbSet sur la doc MS. En gros ça indique que l’entité passé dans le DbSet sera une table en base de données, et que les requêtes LinQ faites seront traduites en SQL.

Il ne reste plus qu’à ajouter dans Program.cs, le code pour faire la connexion, ligne très importante, je reviens un peu plus bas sur cette « connexion« .

// Add Application Db Context options
builder.Services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlite(@"Data Source=TutoCodeFirst.db"));

Génération de la base

Pour que la base de données soit généré par le code, il faut ajouter un autre package : Microsoft.EntityFrameworkCore.Tools

dotnet add package Microsoft.EntityFrameworkCore.Tools

Install-Package Microsoft.EntityFrameworkCore.Tools

C’est avec ce package que nous pourrons générer le code pour créer notre base de données.

Commande pour générer le code.

dotnet ef migrations add InitialCreate

Add-Migration InitialCreate

Une fois la compilation terminée, il y a dans le projet un nouveau répertoire : Migrations.

A l’intérieur se trouve une class InitialCreate, tient j’ai déjà vu ça quelque part, qui hérite de Migration. Elle contient 2 méthodes :

protected override void Up(MigrationBuilder migrationBuilder) {...} voir la doc Migration.Up

protected override void Down(MigrationBuilder migrationBuilder) {...} voir la doc Migration.Down

Il y a aussi la class ApplicationDbContextModelSnapshot, qui hérite de ModelSnapshot (par ici la doc)

Remarque

Le code qui est généré est fait en fonction de la « connexion« . Quand je parle de connexion, c’est options.UseSqlite(...) dans Program.cs. Si j’utilise une autre base de données, par exemple MariaDb/MySQL, j’utiliserai le package : Pomelo.EntityFrameworkCore.MySql au lieu de Microsoft.EntityFrameworkCore.Sqlite, et je mettrai options.UseMySql(...).

Voici un exemple de code généré pour SQLite et pour MySQL, juste sur la table Clients.

 migrationBuilder.CreateTable(
                name: "Clients",
                columns: table => new
                {
                    Id = table.Column<string>(type: "TEXT", nullable: false),
                    Prenom = table.Column<string>(type: "TEXT", nullable: false),
                    Nom = table.Column<string>(type: "TEXT", nullable: false),
                    Age = table.Column<int>(type: "INTEGER", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Clients", x => x.Id);
                });

migrationBuilder.CreateTable(
        name: "Clients",
        columns: table => new
        {
            Id = table.Column<string>(type: "varchar(255)", nullable: false)
                .Annotation("MySql:CharSet", "utf8mb4"),
            Prenom = table.Column<string>(type: "longtext", nullable: false)
                .Annotation("MySql:CharSet", "utf8mb4"),
            Nom = table.Column<string>(type: "longtext", nullable: false)
                .Annotation("MySql:CharSet", "utf8mb4"),
            Age = table.Column<int>(type: "int", nullable: false)
        },
        constraints: table =>
        {
            table.PrimaryKey("PK_Clients", x => x.Id);
        })
        .Annotation("MySql:CharSet", "utf8mb4");

C’est ce qui est génial avec EF Core CodeFirst, sans changer code, nous ne dépendons plus d’une base.

Pour créer la base à partir du code il faut exécuter une des commandes.

dotnet ef database update InitialCreate
# en mettant le nom donné de la migration.

Update-Database

En voici les logs.

Build started...
Build succeeded.
info: Microsoft.EntityFrameworkCore.Infrastructure[10403]
      Entity Framework Core 6.0.1 initialized 'ApplicationDbContext' using provider 'Microsoft.EntityFrameworkCore.Sqlite:6.0.1' with options: None
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (73ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      PRAGMA journal_mode = 'wal';
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (38ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE "__EFMigrationsHistory" (
          "MigrationId" TEXT NOT NULL CONSTRAINT "PK___EFMigrationsHistory" PRIMARY KEY,
          "ProductVersion" TEXT NOT NULL
      );
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (2ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      SELECT COUNT(*) FROM "sqlite_master" WHERE "name" = '__EFMigrationsHistory' AND "type" = 'table';
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      SELECT "MigrationId", "ProductVersion"
      FROM "__EFMigrationsHistory"
      ORDER BY "MigrationId";
info: Microsoft.EntityFrameworkCore.Migrations[20402]
      Applying migration '20220129111929_InitialCreate'.
Applying migration '20220129111929_InitialCreate'.
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE "Clients" (
          "Id" TEXT NOT NULL CONSTRAINT "PK_Clients" PRIMARY KEY,
          "Prenom" TEXT NOT NULL,
          "Nom" TEXT NOT NULL,
          "Age" INTEGER NOT NULL
      );
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE "Commandes" (
          "IdCmd" TEXT NOT NULL CONSTRAINT "PK_Commandes" PRIMARY KEY,
          "ClientId" TEXT NOT NULL
      );
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE "Adresses" (
          "Id" TEXT NOT NULL CONSTRAINT "PK_Adresses" PRIMARY KEY,
          "Numero" TEXT NOT NULL,
          "Rue" TEXT NOT NULL,
          "Ville" TEXT NOT NULL,
          "ClientId" TEXT NOT NULL,
          CONSTRAINT "FK_Adresses_Clients_ClientId" FOREIGN KEY ("ClientId") REFERENCES "Clients" ("Id") ON DELETE CASCADE
      );
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE "Telephones" (
          "Number" TEXT NOT NULL CONSTRAINT "PK_Telephones" PRIMARY KEY,
          "Type" TEXT NOT NULL,
          "ClientId" TEXT NOT NULL,
          CONSTRAINT "FK_Telephones_Clients_ClientId" FOREIGN KEY ("ClientId") REFERENCES "Clients" ("Id") ON DELETE CASCADE
      );
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE TABLE "Paniers" (
          "IdPanier" TEXT NOT NULL CONSTRAINT "PK_Paniers" PRIMARY KEY,
          "IdItem" INTEGER NOT NULL,
          "Quantite" INTEGER NOT NULL,
          "CommandeIdCmd" TEXT NOT NULL,
          CONSTRAINT "FK_Paniers_Commandes_CommandeIdCmd" FOREIGN KEY ("CommandeIdCmd") REFERENCES "Commandes" ("IdCmd") ON DELETE CASCADE
      );
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE UNIQUE INDEX "IX_Adresses_ClientId" ON "Adresses" ("ClientId");
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE INDEX "IX_Paniers_CommandeIdCmd" ON "Paniers" ("CommandeIdCmd");
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      CREATE INDEX "IX_Telephones_ClientId" ON "Telephones" ("ClientId");
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
      Executed DbCommand (0ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
      INSERT INTO "__EFMigrationsHistory" ("MigrationId", "ProductVersion")
      VALUES ('20220129111929_InitialCreate', '6.0.1');
Done.

La création de la base SQLite est faite à la racine du projet et se nomme : TutoCodeFirst.db.

Voilà c’était pour démystifier Entity Framework Core : Code First.

Mutation Testing

Anthony Ryckembusch — Fri, 04 Aug 2023 12:00:01 +0000

Tester son code est obligatoire, mais ça veut dire que ces tests c’est aussi du code, et qui test ce code ? Pas dans le sens algorithmique mais dans leurs véracités.

En décembre 2021, j’ai suivi une conf à l’Agile Tour de Rennes, sur le Mutation Testing, et j’avoue avoir adoré.

Dans ce post je vais montrer comment mettre en place un outil de mutation.

Définition

L’idée du Mutation Testing est de modifier le code « métier » pour voir si les tests échouent. Par exemple, dans une méthode ou il y aurait :

var result = x + y

serait transformé en :

var result = x - y.

En gros l’outils inverses les opérateurs :

+ devient -

* devient /

== devient !=, … Vous avez compris l’idée. (Doc sur les mutations stryker-mutator.io et sur les regex)

Vous allez me dire c’est tout ? Les opérateurs +,-,x,/,==,!=,… ont une énorme importance dans une application. Ce sont eux qui définissent réellement le comportement d’une application. A cela vous ajoutez tous les traitements que nous pouvons faire sur les string.

Modifier le code pour changer tous les opérateurs à la main, ça va prendre beaucoup de temps. Heureusement il existe un outil qui permet d’automatiser ces modifications, d’exécuter les tests et même de générer des rapports.

C’est Stryker.NET (stryker-mutator.io et Github)

Projet de test/démonstration

Sur mon Github j’ai mis un projet pour tester Stryker. Il est composé d’une librairie Business et d’un projet de test Business.Test pour les tests unitaires. La librairie permet de créer des packs de produit via la class Engine. Un produit (une conserve par exemple) est défini par une taille et un poids, et un pack est juste un paquet de 6 produits. Voici les 2 entités :

namespace Business;

public class Produit
{
    public string IdentifiantProduit { get; private set; }

    public double Poids { get; private set; }

    public int Taille { get; private set; }

    /// <summary>
    /// Constructeur d'un produit.
    /// </summary>
    /// <param name="id" />
    /// <param name="poids" />
    /// <param name="taille" />
    public Produit(string id, double poids, int taille)
    {
        IdentifiantProduit = id;
        Poids = poids;
        Taille = taille;
    }
}


public class Pack
{
    /// <summary>Numéro lot </summary>
    public int NumLot { get; private set; }

    /// <summary>Produits contenus dans ce pack</summary>
    public List<Produit> Produits { get; private set; } = new List<Produit>();

    /// <summary>
    /// Constructeur d'un pack
    /// </summary>
    /// <param name="numeroLot" />
    public Pack(int numeroLot)
    {
        NumLot = numeroLot;
    }

    /// <summary>
    /// Ajoute un produit dans le Pack.
    /// </summary>
    /// <param name="produit" />
    public void AddProduit(Produit produit)
    {
        Produits.Add(produit);
    }
}

Comme dit plus haut, la class Engine va traiter des produits pour savoir s’ils sont bon (respecte une taille et un poids), pour pouvoir être packagé. Voici le code :

public class Engine
{
    /// <summary>Liste des produits rejetés</summary>
    public List<Produit> RejetProduits { get; private set; }

    /// <summary>Liste des packs remplis</summary>
    public List<Pack> PacksRemplis { get; private set; }

    /// <summary>Pack en cours de remplissage</summary>
    public Pack PackEnCours { get; private set; }

    /// <summary>Compteur de Pack</summary>
    public int CompteurDuJour {get; private set; }

    /// <summary>Données d'acceptation</summary>
    private ConfigProduit _config;

    /// <summary>Poids minimal acceptable par rapport à la marge</summary>
    public double MargePoidsMin;

    /// <summary>Poids maximal acceptable par rapport à la marge</summary>
    public double MargePoidsMax;

    public Engine(ConfigProduit config, int compteurDepart)
    {
        RejetProduits = new List<Produit>();
        PacksRemplis = new List<Pack>();
        _config = config;
        CompteurDuJour = compteurDepart;

        double marge = config.PoidsIdeal * (config.MargeErreurPoids / 100);
        MargePoidsMin = config.PoidsIdeal - marge;
        MargePoidsMax = config.PoidsIdeal + marge;
    }

    #region Public methods

    /// <summary>
    /// Va traiter une liste de produit pour les "packager"
    /// </summary>
    /// <param name="nouveauProduits" />
    public void Process(IEnumerable<Produit> nouveauProduits)
    {
        foreach (var produit in nouveauProduits)
        {
            if(Validate(produit))
            {
                AddToPack(produit);
            }
            else
            {
                RejetProduits.Add(produit);
            }   
        }
    }

    #endregion

    #region Private methods

    /// <summary>
    /// Permet d'ajouter un produit dans un pack
    /// </summary>
    /// <param name="produit" />Produit acceptable
    private void AddToPack(Produit produit)
    {
        if(PackEnCours == null)
        {
            PackEnCours = new Pack(CompteurDuJour++);   
        }

        PackEnCours.AddProduit(produit);
        if(PackEnCours.Produits.Count == 6)
        {
            PacksRemplis.Add(PackEnCours);
            // Remise à zéro
            PackEnCours = null;
        }       
    }

    /// <summary>
    /// Permet de valider ou non un produit
    /// </summary>
    /// <param name="produit" />
    /// <returns></returns>
    private bool Validate(Produit produit)
    {
        if(produit.Taille != _config.TailleIdeale)
            return false;

        if(!ValidatePoids(produit.Poids))
            return false;

        return true;
    }

    /// <summary>
    /// Valide que le poids du produit est dans la marge d'erreur
    /// </summary>
    /// <param name="poids" />Poids du produit
    /// <returns>TRUE : est acceptable.</returns>
    private bool ValidatePoids(double poids)
    {
        return MargePoidsMin <= poids && poids <= MargePoidsMax;
    }

    #endregion
}

Rien de fou fou, je reste dans un exemple simple, mais je ne voulais pas un exemple avec des méthodes a + b, a > b,….

Installation de Stryker.NET

Installons Stryker localement à un projet. Nous allons utiliser un « outils » dotnet (doc sur les outils dotnet).

Pour installer un outil pour un accès local uniquement (pour le répertoire courant et les sous-répertoires), nous devons ajouter un fichier manifeste. (dotnet new tool-manifest).

Il faut se positionner dans le répertoire du projet voulu et faire les commandes suivantes.

dotnet new tool-manifest

Ça ajoute un répertoire .config, avec un fichier dotnet-tools.json. Ensuite indiquer quel outil installer.

dotnet tool install dotnet-stryker

Ce qui ajoute les informations dans le fichier json.

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "dotnet-stryker": {
      "version": "1.2.1",
      "commands": [
        "dotnet-stryker"
      ]
    }
  }
}

dotnet tool restore

Notre projet est prêt pour subir quelques mutations.

Utilisation de Stryker

Dans le répertoire du projet de test unitaire (Business.Test), il faut exécuter la commande dotnet stryker pour que Stryker nous crée des mutants.

Informations que Stryker affiche.

Version: 1.2.1

[05:05:50 INF] Identifying project to mutate.
[05:05:51 INF] The project C:\CodeSource\Github\AnthonyRyck\CodesPourDevTo\src\dotNet6\TutoMutationTesting\Business\Business.csproj will be mutated.
[05:05:53 INF] Analysis complete.
[05:05:53 INF] Building test project C:\CodeSource\Github\AnthonyRyck\CodesPourDevTo\src\dotNet6\TutoMutationTesting\Business.Test\Business.Test.csproj (1/1)
[05:05:58 INF] Total number of tests found: 3.
[05:05:58 INF] Initial testrun started.
[05:06:00 INF] 37 mutants created
[05:06:00 INF] Capture mutant coverage using 'CoverageBasedTest' mode.
[05:06:01 INF] 37    mutants will be tested because: not run
[05:06:01 INF] 37    total mutants will be tested
100,00% │ Testing mutant 37 / 37 │ K 34 │ S 3 │ T 0 │ ~0m 00s │                                                                                     00:00:19

Killed:   34
Survived:  3
Timeout:   0
Hint: by passing "--open-report or -o" the report will open automatically once Stryker is done.
Your html report has been generated at:
file:///C:/CodeSource/Github/AnthonyRyck/CodesPourDevTo/src/dotNet6/TutoMutationTesting/Business.Test/StrykerOutput/2022-01-05.05-05-50/reports/mutation-report.html
You can open it in your browser of choice.
[05:06:20 INF] Time Elapsed 00:00:30.1037369
[05:06:20 INF] The final mutation score is 91.89 %

Il a créé 37 mutants dans le code, 34 ont pu être tués mais il en reste 3. Il crée aussi un répertoire StrykerOutput dans le répertoire d’exécution de la commande, avec un rapport en html.

Dans le rapport, ouvrons Engine.cs, il y a 2 mutants, tentons de les tuer.

Premier mutant

Donc là il nous montre que le fait de changer le compteur de sens, ça ne perturbe pas du tout les tests unitaires.

Normal… aucun test ne couvre cette partie. J’ajoute un nouveau test unitaire.

[Fact]
public void TestOnNumeroLot()
{
    #region Arrange

    ConfigProduit configTest = new ConfigProduit(100, 5, 20);
    List<Produit> ProduitsTest = new List<Produit>()
    {
        new Produit("produitOk-01", 100, 20),
        new Produit("produitOk-02", 101, 20),
        new Produit("produitOk-03", 102, 20),
        new Produit("produitOk-04", 103, 20),
        new Produit("produitOk-05", 104, 20),
        new Produit("produitOk-06", 105, 20)
    };

    #endregion

    #region Act

    Engine engine = new Engine(configTest, 0);
    engine.Process(ProduitsTest);

    #endregion

    #region Assert

    // doit y avoir 6 produits OK (soit un pack complet), 
    Assert.True(engine.CompteurDuJour == 1, "Il y a qu'un pack complet (6 produits)");
    Assert.True(engine.PacksRemplis[0].NumLot == 0);
    #endregion
}

Le fait de tester si la propriété NumLot == 0 élimine le mutant. Stryker, en mettant -- il sera détecté.

Deuxième mutant

Là le poids minimal n’est pas testé s’il est sur la marge inférieure. J’ai beau avoir des tests avec des poids différents, mais je n’en ai pas un qui va tester sur les poids qui tendent vers le mini, je faisais que sur des poids qui aller sur la marge supérieure.

Ajout d’un nouveau test unitaire :

[Fact]
public void TestOnPoidsMinimal()
{
    #region Arrange

    ConfigProduit configTest = new ConfigProduit(100, 5, 20);
    List<Produit> ProduitsTest = new List<Produit>()
    {
        new Produit("produitOk-01", 100, 20),
        new Produit("produitOk-02", 99, 20),
        new Produit("produitOk-03", 98, 20),
        new Produit("produitOk-04", 97, 20),
        new Produit("produitOk-05", 96, 20),
        new Produit("produitOk-06", 95, 20),
        new Produit("produitNOk-07", 94, 20)
    };

    #endregion

    #region Act

    Engine engine = new Engine(configTest, 0);
    engine.Process(ProduitsTest);

    #endregion

    #region Assert

    // doit y avoir 6 produits OK (soit un pack complet), 
    Assert.True(engine.CompteurDuJour == 1, "Il y a qu'un pack complet (6 produits)");
    Assert.True(engine.PacksRemplis[0].NumLot == 0);
    Assert.True(engine.RejetProduits.Count == 1, "Il y a un rejet, poids trop bas");

    #endregion
}

Là j’ai le poids 94 grammes qui sera en rejet, normal, et c’est avec le produit avec un poids de 95 grammes, qui est sur la limite de la marge inférieure, que le mutant sera détecté.

Je relance la commande dotnet stryker.

Version: 1.2.1

[05:38:31 INF] Identifying project to mutate.
[05:38:33 INF] The project C:\CodeSource\Github\AnthonyRyck\CodesPourDevTo\src\dotNet6\TutoMutationTesting\Business\Business.csproj will be mutated.
[05:38:34 INF] Analysis complete.
[05:38:34 INF] Building test project C:\CodeSource\Github\AnthonyRyck\CodesPourDevTo\src\dotNet6\TutoMutationTesting\Business.Test\Business.Test.csproj (1/1)
[05:38:38 INF] Total number of tests found: 4.
[05:38:38 INF] Initial testrun started.
[05:38:40 INF] 37 mutants created
[05:38:40 INF] Capture mutant coverage using 'CoverageBasedTest' mode.
[05:38:41 INF] 37    mutants will be tested because: not run
[05:38:41 INF] 37    total mutants will be tested
100,00% │ Testing mutant 37 / 37 │ K 36 │ S 1 │ T 0 │ ~0m 00s │   
00:00:17

Killed:   36
Survived:  1
Timeout:   0
Hint: by passing "--open-report or -o" the report will open automatically once Stryker is done.
Your html report has been generated at:
file:///C:/CodeSource/Github/AnthonyRyck/CodesPourDevTo/src/dotNet6/TutoMutationTesting/Business.Test/StrykerOutput/2022-01-05.05-38-31/reports/mutation-report.html
You can open it in your browser of choice.
[05:38:58 INF] Time Elapsed 00:00:27.1282839
[05:38:58 INF] The final mutation score is 97.30 %

Et le rapport.

Nous pouvons voir que nous avons tués les 2 mutants.

Pour conclure

Avec Stryker j’ai pu voir que certaines parties du code n’étaient pas testés et il pouvait nous ajouter des mutants sans que les tests unitaires ne voient rien. Ensuite, il nous a aussi montré que sur des méthodes qui ont tests, il pouvait aussi ajouter des mutants sans problème… C’est un outil qui vient en complément avec les tests unitaires et d’autres métriques. Evitons de nous retrouver avec une couverture de code à 97%, mais qu’au final ces tests ne sont là que pour gonfler une métrique sans réel apport pour le projet, et de nous retrouver seul face à innombrables potentiels bugs.

Découverte de GraphQL

Anthony Ryckembusch — Fri, 04 Aug 2023 11:57:09 +0000

Marre d’avoir des retours de votre API avec la moitié de la base de données, alors que vous vouliez juste connaitre un ID d’un champ en particulier ?

Fatigué d’avoir à faire des end points en masse, pour avoir un type de retour, puis un autre, et encore un autre, pour au final dire, « Au puis merde, je vais tout ramener, et je ferais le tri des patates dans l’application… »

GraphQL est là pour vous simplifier la vie.

Qu’est-ce que GraphQL

GraphQL (pour Graph Query Language) est un langage de requêtes et un environnement d’exécution, créé par Facebook en 2012, avant d’être publié comme projet open-source en 2015. Inscrit dans le modèle Client-Serveur, il propose une alternative aux API REST. La requête du client définit une structure de données, dont le stockage est éventuellement distribué, et le serveur suit cette structure pour retourner la réponse. Fortement typé, ce langage évite les problèmes de retour de données insuffisants (under-fetching) ou surnuméraires (over-fetching).

GraphQL — Wikipédia (wikipedia.org)

Projet de test

Le code source du projet est sur GitHub.

Dans ce post je vais utiliser le package HotChocolate.AspNetCore de ChilliCream.

Pour découvrir GraphQL, nous allons créer notre serveur web. Cet exemple sera une API permettant d’avoir des informations sur des personnes. Les données sont stockées dans un JSON, et voici un exemple de personne.

{
  "id": "70f05566-1386-425d-bec3-d20b9c8e88fa",
  "index": 0,
  "isActive": true,
  "age": 40,
  "name": "Florence Wade",
  "gender": "female",
  "company": "VICON",
  "email": "florencewade@vicon.com",
  "phone": "+1 (942) 437-2165",
  "address": "405 Times Placez, Motley, Nevada, 9643",
  "about": "Id reprehenderit aute laborum do eiusmod qui reprehenderit dolore. Proident reprehenderit duis do duis minim commodo aute id. Anim incididunt in irure fugiat ipsum ex. Aliqua officia sunt excepteur proident tempor ex.\r\n",
  "registered": "2021-08-18T04:16:38 -02:00",
  "latitude": 8.848137,
  "longitude": 73.653237,
  "friends": [
    {
      "id": 0,
      "name": "Johnston Zamora"
    },
    {
      "id": 1,
      "name": "Clarke Blair"
    },
    {
      "id": 2,
      "name": "Lindsey Chandler"
    }
  ],
  "greeting": "Hello, Florence Wade! You have 2 unread messages.",
  "favoriteFruit": "apple"
}

Création du projet de test

Toute la création du projet se fera en ligne de commande, parce que nous adorons ça !

# création d'un projet web vide.
dotnet new web --output TutoGraphQL

Il faut ajouter les packages suivant.

dotnet add .\TutoGraphQL package HotChocolate.AspNetCore
dotnet add .\TutoGraphQL package HotChocolate.Data

HotChocolate.AspNetCore contient le middleware GraphQL ASP.NET Core pour Hot Chocolate. De plus, ce package comprend le middleware Banana Cake Pop, qui fournit un IDE GraphQL (c’est l’IDE sur l’exemple que j’ai mis en live). Cela permet de tester des requêtes.
HotChocolate.Data contient des extensions prêtes à l’emploi pour la gestion des données dans HotChocolate (filtrage, projections et tri). ### Ajout du schéma GraphQL

Le schéma GraphQL est défini par des entités. Dans notre cas, se seront Personne et Friend.

namespace TutoGraphQl.Models
{
    public class Personne
    {
        public Guid id { get; set; }
        public int index { get; set; }
        public bool isActive { get; set; }
        public int age { get; set; }
        public string name { get; set; }
        public string gender { get; set; }
        public string company { get; set; }
        public string email { get; set; }
        public string phone { get; set; }
        public string address { get; set; }
        public string about { get; set; }
        public string registered { get; set; }
        public float latitude { get; set; }
        public float longitude { get; set; }
        public Friend[] friends { get; set; }
        public string greeting { get; set; }
        public string favoriteFruit { get; set; }
    }
}

namespace TutoGraphQl.Models
{
    public class Friend
    {
        public int id { get; set; }
        public string name { get; set; }
    }
}

Ajout du service de donnée

Il faut ajouter un répertoire Data, et ajouter l’interface et son implémentation pour « gérer » les personnes.

namespace WebApiGraphQl.Data
{
    public interface IDataAccess
    {
    /// <summary>
    /// Retourne toutes personnes
    /// </summary>
    /// <returns></returns>
    IEnumerable<Personne> GetAll();

    /// <summary>
    /// Retourne la personne par rapport à son ID
    /// </summary>
    /// <param name="id" />
    /// <returns></returns>
    Personne GetPersonne(Guid id);
    }
}

using System.Text.Json;

namespace WebApiGraphQl.Data
{
    public class DataAccess : IDataAccess
    {
        private IEnumerable<Personne> AllPeople;

        public DataAccess()
        {
            // Chargement des données JSON.
            string pathJson = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "JsonFile", "personnes.json");

            StreamReader reader = new StreamReader(pathJson);
            AllPeople = JsonSerializer.Deserialize< /><Personne>>(reader.ReadToEnd());
        }

        /// <inheritdoc cref="IDataAccess.GetAll"></inheritdoc>
        public IEnumerable<Personne> GetAll()
        {
            return AllPeople;
        }

        /// <inheritdoc cref="IDataAccess.GetPersone(Guid)"></inheritdoc>
        public Personne GetPersonne(Guid id)
        {
            return AllPeople.FirstOrDefault(x => x.id == id);
        }   
    }
}

Déclaration de ce nouveau service dans Program.cs

var builder = WebApplication.CreateBuilder(args);

// Service pour "gerer" les donnees
builder.Services.AddSingleton<IDataAccess, DataAccess="">();
// [...] reste du code.</IDataAccess,>

Définir notre résolveur

Un résolveur agit comme un gestionnaire de requêtes GraphQL. Dans notre exemple, nous allons créer une méthode racine ElRequetor qui expose les requêtes possibles qu’un utilisateur peut explorer. Créons un répertoire RequetesGraph, et ajoutons la nouvelle class ElRequetor.

namespace WebApiGraphQl.RequetesGraph
{
    public class ElRequetor
    {
        private IDataAccess _access;

        public ElRequetor(IDataAccess dataAccess)
        {
            _access = dataAccess;
        }

        [UseSorting]
        [UseFiltering]
        public IEnumerable<Personne> GetPersonnesAsync()
        {
            return _access.GetAll();
        }

        public Personne GetPersonneById(Guid id)
        {
            return _access.GetPersonne(id);
        }

        [UseSorting]
        public Personne GetFriendsById(Guid id)
        {
            return _access.GetPersonne(id);
        }
    }
}

J’expose 2 méthodes pour interroger les données.

GetPersonnesAsync() retourne l’ensemble des personnes, et il a les attributs [UseSorting] qui permet d’indique un classement (doc Sorting), et [UseFiltering] qui permet de filtrer (doc Filtering).
La 2eme méthode donne une personne en fonction de l’id passé en paramètre. ### Configuration du serveur

Il faut ajouter dans Program.cs les middlewares à notre serveur. Voici le code complet de Program.cs.

using WebApiGraphQl.RequetesGraph;

var builder = WebApplication.CreateBuilder(args);

// Service pour "gerer" les donnees
builder.Services.AddSingleton<IDataAccess, DataAccess="">();

builder.Services.AddGraphQLServer()
                .AddQueryType<ElRequetor>()
                .AddFiltering()
                .AddSorting();

var app = builder.Build();

app.MapGraphQL("/");

app.Run();

Testons l’application

En exécutant le code, ou en allant sur le live, vous aurez l’IDE Banana Cake Pop. Cet IDE permet de tester les requêtes GraphQL. Il y a un système d’intellisense (comme le montre l’image).

Notre première requête (ci-dessous) récupère sur l’ensemble des personnes, leur id, nom et email. Je prends que ce dont j’ai besoin !

query{
  personnesAsync
  {
    id
    name
    email
  }
}

personnesAsync… Tient tient, mais c’est le nom de ma méthode dans mon resolver. Ok il manque le Get.

Nous avons comme résultat.

La 2eme requête est sur la même méthode, je veux que l’ID et le nom, et surtout utiliser un classement différent. Je veux que le classement soit faire sur le nom et de Z à A.

query{
  personnesAsync (order: {name:DESC}) {
    id
    name  
  }
}

Comme cette méthode porte l’attribut UseSorting, cela me permet d’indiquer un ordre différent, et sur quelle propriété.

Maintenant, je veux avoir la liste des amis d’une seule personne en particulier.

query{
  personneById(id: "feecf00e-609d-4eae-ba49-6328c0b84248") {
    friends
    {
      id
      name
    }
  }
}

personneById ! Quand je vous disais que ce sont les mêmes noms que le resolver ! Vous voyez comment passer un paramètre à la requête. Maintenant, j’indique que je veux que la propriété friends, et que l’id et le nom des amis.

Pas d’image pour celle-là, je vous laisse l’essayer.

Comme cette méthode n’a pas d’attribut Sorting, l’intellisense ne propose pas order, comme avec la méthode friendsById.

J’ai fait une méthode qui prend en paramètre l’id d’une personne, mais j’aurais pu utiliser un filtre. La méthode personneAsync a comme autre attribut UseFiltering, ce qui permet d’indiquer à la requête un filtre. Voici la requête qui donnera le même résultat. (Voir la doc sur le filtering de ChilliCream)

query {
  personnesAsync(where: {id:{eq:"feecf00e-609d-4eae-ba49-6328c0b84248"}})
  {
    id
    name
  }
}

C’est le petit mot clé eq qui fait tout 😉

D’autres packages nuget permettent d’intégrer GraphQL avec MongoDb, EntityFramework, Neo4J, … (Integration).

Voilà fini pour cette découverte, il reste encore tellement de chose à voir, (les mutations, ajout/suppression/update des données), mais je vous laisse découvrir ce merveilleux outil.

Découverte de Spectre.Console

Anthony Ryckembusch — Fri, 04 Aug 2023 11:53:32 +0000

Qu’est-ce que Spectre.Console ?

C’est une librairie qui permet de faire des projets Console bien plus… Bling Bling.

LINK TO VIDEO

Le projet est OpenSource sur GitHub : Spectre.Console et toute la documentation est sur spectreconsole.net. Pour cette découverte, nous allons faire un projet console pour ce blog (ctrl-alt-suppr).

Création du projet

Il faut créer un projet console ou il faut ajouter 2 librairies : Spectre.Console et Spectre.Console.ImageSharp. La 2eme est une librairie qui étend les fonctionnalités de Spectre sur les images, vous verrez, c’est bien sympa. Voici les commandes pour créer le projet :

dotnet new console -o ConsoleBlingBling
dotnet add .\ConsoleBlingBling package Spectre.Console
dotnet add .\ConsoleBlingBling package Spectre.Console.ImageSharp

Le logo

Au lancement de l’application, j’aimerai afficher le « logo » du blog, ou du moins ce qui s’en rapproche le plus. J’ai fait cette image :

Vous allez me dire :

« Mais dans une application console, on ne peut pas afficher d’image »

Spectre va jouer sur les couleurs de background et faire une sorte de « ACSII art » de l’image, et c’est avec le package Spectre.Console.ImageSharp que nous pourrons faire ça.

Ajoutons le code :

using Spectre.Console;

// Image pour le logo
var logo = new CanvasImage("logo.jpg");
AnsiConsole.Write(logo);
AnsiConsole.WriteLine(); // pour faire un espace

C’est AnsiConsole qui faut utiliser à la place de la class Console (doc Console). Comme l’image est à la racine du projet et copié à chaque fois à la compilation, il faut juste mettre le nom. Le csproj :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <None Include="logo.jpg">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Spectre.Console" Version="0.43.0"></PackageReference>
    <PackageReference Include="Spectre.Console.ImageSharp" Version="0.43.0"></PackageReference>
  </ItemGroup>
</Project>

Il est possible de compiler l’image dans l’exe en utilisant EmbeddedResource, dans le csproj :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <EmbeddedResource Include="logo.jpg"></EmbeddedResource>
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Spectre.Console" Version="0.43.0"></PackageReference>
    <PackageReference Include="Spectre.Console.ImageSharp" Version="0.43.0"></PackageReference>
  </ItemGroup>
</Project>

En revanche pour charger l’image, il faut utiliser la Reflection :

using System.Reflection;

Stream logoStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ConsoleBlingBling.logo.jpg");
CanvasImage logo = new CanvasImage(logoStream);
AnsiConsole.Write(logo);

Dans la méthode GetManifestResourceStream(), il faut indiquer le namespace complet (donc attention si l’image est dans un répertoire) et le nom du fichier.

Le slogan

Maintenant je veux ajouter le slogan du blog.

// Slogan
var slogan= new FigletText("Partager du code")
            .RightAligned()
            .Color(Color.White);
AnsiConsole.Write(slogan);

FigleText (doc spectre) permet de convertir le string passé en paramètre en FIGlet (définition).

Voilà ce que ça donne :

Le fond avec les étoiles est mon background de mon Windows Terminal. Dans les best-practices de Spectre, il indique que le rendu peut être « gâché » (c’est ma traduction 🙂) en fonction de comment est configuré la sortie de l’utilisateur. Si vous mettez une grande image, et que l’utilisateur a une fenêtre de console toute petite, ça va sortir un résultat très différent de ce que vous vous attendiez.

Maintenant que j’ai mis le logo et le slogan, je veux que cette application récupère les 10 derniers articles pour les afficher dans un menu.

Récupération des articles

Pendant que la console récupère les articles, je veux qu’elle affiche un « waiting », une animation pour faire patienter l’utilisateur. Je vais utiliser AnsiConsole.Status() (doc spectre).

Voici le code :

// Affichage des 10 derniers articles du blog.
List<PostWordPress> posts = new List<PostWordPress>();

await AnsiConsole.Status()
            .StartAsync("Récupération des 10 derniers post...", async ctx => 
            {
                // Change le "waiting".
                ctx.Spinner(Spinner.Known.Aesthetic);

                using(var client = new HttpClient())
                {
                    string url = @"https://www.ctrl-alt-suppr.dev/wp-json/wp/v2/posts?per_page=10";
                    var streamPosts = await client.GetStreamAsync(url);
                    posts = await JsonSerializer.DeserializeAsync< /><PostWordPress>>(streamPosts);
                }
                // Pour avoir le temps de voir le "waiting".
                await Task.Delay(5000);
                AnsiConsole.MarkupLine(":check_mark: Terminé " + Emoji.Known.CheckMark);
            });

L’animation sera affichée jusqu’à la fin du StartAsync(). Il est possible de choisir le type d’animation, avec l’option Spinner (ctx.Spinner(Spinner.Known.Aesthetic);). Dans mon cas j’ai mis : Aesthetic, mais vous trouverez tous les exemples ici.

Note : J’ai mis un await Task.Delay(5000), car à l’air de la fibre vous ne verrez quasiment pas le « waiting ».

Sur la dernière ligne :

AnsiConsole.MarkupLine(":check_mark: Terminé " + Emoji.Known.CheckMark);

J’ai fait exprès de mettre les 2 manières de mettre des Emojis, soit c’est une chaine de caractère (:check_mark:) ou de passer par l’énumération Emoji.Know.

Menu pour les articles

Je vais faire un menu rapide qui donnera le choix à l’utilisateur entre les 10 articles, de réafficher le menu ou de quitter l’application.

string cmdQuit = "quit";
string selection = string.Empty;

ShowPosts();

while(selection != cmdQuit)
{
    AnsiConsole.WriteLine();
    selection = AnsiConsole.Ask<string>("Quel est votre choix ?");

    switch (selection)
    {
        case "quit":
            AnsiConsole.WriteLine();
            AnsiConsole.MarkupLine("See you soon " + Emoji.Known.OkHand);
            AnsiConsole.WriteLine();
            Environment.Exit(0);
            break;
        case "posts":
            ShowPosts();
            break;
        case "1":
        case "2":
        case "3":
        case "4":
        case "5":
        case "6":
        case "7":
        case "8":
        case "9":
        case "10":
            int index = int.Parse(selection);
            string urlPost = posts[index - 1].link;
            try
            {
                ProcessStartInfo startInfo = new ProcessStartInfo(@"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe");
                startInfo.WindowStyle = ProcessWindowStyle.Maximized;
                startInfo.Arguments = urlPost;
                Process.Start(startInfo);
                AnsiConsole.MarkupLine("[green]Bonne lecture[/] :grinning_face_with_big_eyes:");
            }
            catch (System.Exception ex)
            {
                AnsiConsole.MarkupLine("[red]ERREUR [/] :angry_face:");
                AnsiConsole.MarkupLine("Edge n'a pas pu être ouvert, du coup voici l'URL de l'article choisi :");
                AnsiConsole.MarkupLine(urlPost);
            }
            break;
        default:
            AnsiConsole.MarkupLine("[red]Euuhhh le choix n'est pas compliqué...[/] :angry_face:");
            AnsiConsole.MarkupLine(string.Empty);
            break;
    }
}

void ShowPosts()
{
    // Affichage des posts.
    for (var i = 0; i < posts.Count; i++)
    {
        AnsiConsole.MarkupLine($"[purple]{i + 1}[/] - {posts[i].date.ToString("d")} - {posts[i].title.rendered}");
    }
    AnsiConsole.MarkupLine("[green]posts[/] : pour réafficher la liste des articles.");
    AnsiConsole.MarkupLine("[red]quit[/] : pour quitter.");
}

Qu’est ce qui est important.

selection = AnsiConsole.Ask<string>("Quel est votre choix ?"); Il remplace Console.ReadLine(); ou Console.ReadKey();, et la sortie peut être directement typé.
AnsiConsole.MarkupLine("See you soon " + Emoji.Known.OkHand); MarkupLine équivaut à AnsiConsole.Write(new Markup(".....")); Je vous laisse lire la doc pour lui, car il permet de changer de couleur le texte, souligner, mettre des emojis,… enfin c’est lui qui rend la vie plus be

Pour changer la couleur : AnsiConsole.MarkupLine("[red]quit[/] : pour quitter.");

Spectre va parser la chaine de string. Par exemple, pour avoir du rouge il faut écrire : [red] et ne PAS OUBLIER le [/] pour indiquer la fin, sinon Exception. Comme c’est dans une chaine de string, votre IDE ne va pas vous aider à trouver l’erreur.

Attention

Pour la découverte, quand l’utilisateur choisira un article ça lui ouvre l’application Edge, donc si vous utilisez un Mac/Linux ça ne fonctionnera pas (testé sous Win10 et Win11).

Et on peut faire du Scripting ?

Nous venons de créer un projet console, et si on le scriptait ? Pour voir comment faire/utiliser un script en C#, aller voir le post : Tips & Tricks – Du script en C#.

Dans ce script, je reprends à 99% le code du projet console. Vous retrouvez le script sur GitHub, et pour l’exécuter en direct voici la commande :

dotnet script https://raw.githubusercontent.com/AnthonyRyck/CodesPourDevTo/master/src/dotNetScript/SpectreScript/main.csx

Voilà, maintenant je suis un adepte de ces librairies, je pense même refaire certains de mes projets avec 😉 Il y a encore tellement à découvrir (les tableaux, les commandes,…), mais je vous laisse faire vos propres tests.

Blazor - Créer un utilisateur Root au démarrage de l'application

Anthony Ryckembusch — Thu, 22 Oct 2020 07:41:44 +0000

J'aime bien créer un utilisateur "root" qui a le rôle "admin" dans l'application. Dans cet article, je vais vous expliquer comment faire. J'utilise une base de données SQLite, mais cela fonctionne avec toutes les bases de données, tant qu'on utilise EntityFramework.

Commençons par la class Startup.cs, dans la méthode ConfigureServices, il faut vérifier et ajouter si besoin, les lignes suivantes :

services.AddDbContext<ApplicationDbContext>(options =>        
options.UseSqlite(Configuration.GetConnectionString("DefaultConnection")));

services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
                .AddRoles<IdentityRole>() // <--- Important
                .AddEntityFrameworkStores<ApplicationDbContext>();

Ces lignes permettent d'ajouter la connexion à SQLite avec la configuration du nom de DefaultConnection. Le "AddRoles" nous permettra d'appeler IdentityRole.

Voici le DefaultConnection

"ConnectionStrings": {
    "DefaultConnection": "DataSource=database/app.db"

Le fichier de base de données sera dans un répertoire database. Ce répertoire sera créé au lancement de l'application.
Attention : Quand vous serez dans une session debug, le répertoire sera créé dans votre solution, là où se trouve le code source, pas dans le répertoire bin\debug... Quand l'application sera déployée ce répertoire sera créé là se trouve les binaires.

Ensuite, il faut créer une class static DataInitializer et ajouter cette propriété et cette méthode :

//NOTE : Mettre les noms des rôles que vous voulez.
private static readonly string[] Roles = new string[] { "Admin", "Manager", "Member" };

public static async Task InitData(RoleManager<IdentityRole> roleManager, UserManager<IdentityUser> userManager)
{

    foreach (var role in Roles)
    {
        if (!await roleManager.RoleExistsAsync(role))
        {
            await roleManager.CreateAsync(new IdentityRole(role));
        }
    }
    // Création de l'utilisateur Root.
    var user = await userManager.FindByNameAsync("root@email.com");
    if (user == null)
    {
        var poweruser = new IdentityUser
        {
            UserName = "root@email.com",
            Email = "root@email.com",
            EmailConfirmed = true
        };
        string userPwd = "Azerty123!";
        var createPowerUser = await userManager.CreateAsync(poweruser, userPwd);
        if (createPowerUser.Succeeded)
        {
            await userManager.AddToRoleAsync(poweruser, "Admin");
        }
    }
}

Cette méthode permet d'ajouter les rôles voulus, de créer l'utilisateur root, et de lui mettre le rôle Admin.

Ensuite, il faut appeler cette méthode au démarrage de l'application, donc dans le Main de la Class Program.cs

public static void Main(string[] args)
{
    var host = CreateHostBuilder(args).Build();

    // Création du répertoire pour la base de données
    string pathDatabase = Path.Combine(AppContext.BaseDirectory, "database");
    if(!Directory.Exists(pathDatabase))
        Directory.CreateDirectory(pathDatabase);

    var scopeFactory = host.Services.GetRequiredService<IServiceScopeFactory>();
    using (var scope = scopeFactory.CreateScope())
    {
        var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
        var roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<IdentityRole>>();
        var userManager = scope.ServiceProvider.GetRequiredService<UserManager<IdentityUser>>();

        // Vrai si la base de données est créée, false si elle existait déjà.
        if (db.Database.EnsureCreated())
        {
            DataInitializer.InitData(roleManager, userManager).Wait();
        }
    }

    host.Run();
}

Au lancement de l'application, un Scope est créé pour pouvoir récupérer les services IdentityRole, ApplicationDbContext et IdentityUser. Une vérification que la base de données est créée, si le fichier n'existe pas, il sera créé automatiquement. L'appel à DataInitializer.InitData pour la création de notre utilisateur "root".

Voilà, vous pouvez retrouver le code source sur GitHub.