MyWebAPITemplate

Mon modèle d'API Web

Modèle de démarrage pour toutes sortes d'API REST avec ASP.NET Core

Ceci est mon opinion, fonctionne constamment en cours, modèle de démarrage, pour construire des API REST.

Ce modèle est pour vous si vous voulez juste commencer avec le codage, voulez une structure de projet déjà pensée, qui est assez simple et rapide à apprendre, et fonctionne très bien sur des projets plus petits et plus grands.

Détails

Technologies, cadres et bibliothèques

• Langage de programmation: C #
• Framework: ASP.NET Core 7 (toujours la dernière version)
• Base de données: SQL Server (également possible d'utiliser d'autres bases de données)
• ORM: Framework Entity
• Test: Xunit, MOQ et Fluentassertions

Architecture, fonctionnalités et motifs

• Application de processus unique (monolithique)
• Architecture propre / oignon
• Suit les principes de l'API REST les plus habituels
• Structure de code qui gère les cas d'utilisation les plus typiques en pensant à l'échelle
• Swagger / OpenAPI avec UI
• Configurations de développement / QA / Production
• Semis de base de données
• Gestion des erreurs globales
• Cartographie du modèle
• Validations
• Tests complets (tests fonctionnels, d'intégration et d'unité)
• Enregistrement
• Modèle de référentiel
• Support Docker
• ..et plus dans Backlog

Structure du dossier de modèle

 app                               -> App and related files
 ├─> src                          -> App source
 │   ├─> Web                      -> Entry point for API - runnable project
 │   │   ├─> Controllers          -> API endpoints
 │   │   ├─> Extensions           -> Extension methods
 │   │   ├─> Interfaces           -> Web project's interfaces
 │   │   ├─> Mappers              -> Model mappers
 │   │   ├─> Middlewares          -> Middlewares (e.g. global error handling)
 │   │   |─> Models               -> Models in and out of API
 │   │   ├─> Settings             -> Options pattern for App (e.g. connection strings)
 │   │   ├─> Validators           -> Model validation rules
 │   │   ├── Program.cs           -> START
 │   │   └── Startup.cs           -> START
 │   ├─> Core                     -> Holds business logic
 │   │   ├─> Dtos                 -> Data-transfer-object (used for business logic)
 │   │   ├─> Entities             -> Entity Framework entities for database 
 │   │   ├─> Interfaces           -> Core project's interfaces
 │   │   ├─> Mappers              -> Dto and Entity mappers
 │   │   ├─> Services             -> Business logic services
 │   └─> Infrastructure           -> Data access and external services 
 │       ├─> Database             -> Database access
 │       │   ├─> Configurations   -> Entity Framework table configurations
 │       │   ├─> Migrations       -> Entity Framework autogenerated migrations
 │       │   ├─> Repositories     -> Repository pattern
 │       │   ├── AppDbContext.cs  -> Base context
 │       │   ├── AppSeed.cs       -> Database seeding
 │       │   └── EfRepository.cs  -> Base repository
 │       └─> ExternalServices     -> Services that access external services (e.g. ext. email service)
 └─> tests                        -> App tests
     ├── FunctionalTests          -> Endpoint tests etc.
     │   ├─> Tests                -> All tests
     │   └─> Utils                -> Utility functions (e.g. test database setup)
     ├── IntegrationTests         -> Database tests etc.
     │   ├─> Tests                -> All tests
     │   ├─> Utils                -> Utilities functions (e.g. test database setup)
     ├── UnitTests                -> Application logic tests etc.  
     │   ├─> Tests                -> All tests
     │   ├─> Utils                -> Utility functions 
     └── Shared                   -> Model builders and other shared functions for tests

Usage

Sous les fenêtres

1. Télécharger le dernier SDK .net (https://dotnet.microsoft.com/download)
2. Lors de l'exécution de la première fois - Initialisez la base de données

   •  dotnet tool install --global dotnet-ef
     dotnet ef database update -c ApplicationDbContext -p . /src/Infrastructure/Infrastructure.csproj -s . /src/Web/Web.csproj

3. Lancement
   • Option 1. Lancement sur Visual Studio
     1. Ouvert avec MyWebAPITemplate.sln
     2. Appuyez sur F5 ou Debug/Start Debugging
   • Option 2. Lancement sur CLI

     1.  dotnet run -p . /src/Web/

4. Accédez à https: // localhost: 5001 / swagger / index.html

Multiplateforme avec Docker (en cours)

1. Actuellement possible uniquement avec en mémoire

Nouvelles migrations de base de données

Lorsque vous devez créer une nouvelle migration (lorsque vous modifiez le schéma de la base de données), exécutez cette commande pour dire entité Framework pour gérer les modifications du schéma nécessaire pour la base de données.

 dotnet ef migrations add NewMigrationNameHere --context ApplicationDbContext -p . /src/Infrastructure/Infrastructure.csproj -s . /src/Web/Web.csproj -o Database /Migrations 

Motivation

Ce projet a commencé comme ma façon de gérer le flux d'informations de tout ce qui doit être fait lors de la construction d'API de manière monolithique unique. Il y a tellement de choses à retenir et il y a une grande quantité de choix à faire. Par conséquent, j'ai fait ce modèle, pour moi, pour stocker toutes les pratiques que j'ai trouvées pratiques et j'espère que ce modèle pourrait également aider quelqu'un d'autre à apprendre une chose ou deux.

Dans ce modèle, j'ai recueilli ma connaissance de la construction d'API dans un format pratique. Les préférences architecturales, les sélections de bibliothèques et autres choix sont faites, sur la base des meilleures pratiques, de la popularité et de mes propres préférences d'opinion. Le but de ce modèle est de fournir un bon exemple de base sur la façon de créer des API REST avec ASP.NET qui sont évolutives, faciles à manquer et contiennent les configurations nécessaires et autres goodies. Ce modèle est inspiré de l'application de référence Microsoft EshoponWeb et bien d'autres.

Objectifs

• Pour améliorer le modèle à chaque fois que je trouve quelque chose d'utile, ou je trouve une nouvelle meilleure façon de gérer une partie du programme.
• Pour utiliser uniquement des concepts ou des technologies que j'ai déjà utilisés dans certains de mes projets précédents, donc je sais si cela en vaut la peine. Ce projet n'est pas pour bricoler toutes les choses expérimentales, il y a d'autres projets pour cela :)
• Pour garder la structure simple, mais pas trop simple. Cette structure de projet peut sembler un peu excessive pour l'application TODO, mais la structure est là pour montrer une façon de gérer la structure du code sur des projets plus grands. La structure du code doit être en mesure de gérer des systèmes plus grands avec une plus grande quantité de code et de fonctionnalités.
• Pour garder le modèle comme "monolithique", car je pense que cela pourrait être la meilleure façon de démarrer un nouveau projet. Lire la suite ici
• Être opiniâtre, mais je pense toujours être prêt à changer quoi que ce soit s'il y a une meilleure façon de faire

Contribution et licence

Ce projet est sous licence MIT - alors n'hésitez pas à l'utiliser de toute façon. Les suggestions et l'aide sont les bienvenues. ?