This is a solution template for creating a Single Page App (SPA) with React Js and ASP.NET Core 3 following the principles of Clean Architecture. Create a new project based on this template by clicking the above Use this template button or by installing and running the associated NuGet package (see Getting Started for full details).
- .NET Core 6
- ASP .NET Core 6
- Entity Framework Core 6
- React Js (comming soon)
The easiest way to get started is to install the NuGet package and run dotnet new ca-sln
:
- Install the latest .NET Core SDK
- Run
dotnet new --install Clean.Architecture.Solution.Template
to install the project template - Run
dotnet new ca-sln
to create a new project - Navigate to
src/WebUI
and rundotnet run
to launch the project
This will contain all entities, enums, exceptions, interfaces, types and logic specific to the domain layer.
This layer contains all application logic. It is dependent on the domain layer, but has no dependencies on any other layer or project. This layer defines interfaces that are implemented by outside layers. For example, if the application need to access a notification service, a new interface would be added to application and an implementation would be created within infrastructure.
This layer contains classes for accessing external resources such as file systems, web services, smtp, and so on. These classes should be based on interfaces defined within the application layer.
This layer is a single page application based on Angular 8 and ASP.NET Core 3. This layer depends on both the Application and Infrastructure layers, however, the dependency on Infrastructure is only to support dependency injection. Therefore only Startup.cs should reference Infrastructure.
If you are having problems, please let us know by raising a new issue.
This project is licensed with the MIT license.
Dans cet Projet, nous accomplirons les tâches suivantes : Create src & test folders
Create ASP.NET Core Web API C# version FeedbackService.Api
Create .NET Core class library for Core FeedbackService.Core
Create .NET Core class library for Infrastructure FeedbackService.Infrastructure
Create .Xunit project for API FeedbackService.Api.Tests
Create .Xunit project for Core FeedbackService.Core.Tests
Create .Xunit project for Infrastructure FeedbackService.Infrastructure.Tests
Create .gitignore file
Create .gitattribute file
Push the code into Git
Pull the code from Git
Commit changes into remote Git
Create new feature branch called feature-branches for next set of changes
Create folder structure & files for API
ApiConstants.cs AppSettings.cs DependencyInjection.cs FeedbackService.Api.xml KeyVaultCache.cs ServiceDescription.md ServiceExtensions.cs SwaggerConfiguration.cs Middlewares HttpCodeAndLogMiddleware.cs Helper MapperProfile.cs HealthCheck MemoryHealthCheck.cs HealthCheck RemoteHealthCheck.cs SwaggerExamples Requests FeedbackRequestExample.cs Response FeedbackResponseExample.cs V1 Controllers FeedbackController.cs V2 Controllers FeedbackController.cs Create folder structure & files for Core
Constants ContentTypes.cs Exception Interfaces Models Services Exception ApiException.cs DomainException.cs NotFoundException.cs ValidationException.cs Interfaces Repositories IFeedbackRepository.cs Interfaces Services IFeedbackService.cs Models Feedback.cs Services -FeedbackService.cs Create folder structure & files for Infrastructure
Context FeedbackDbContext.cs Entities Feedback.cs Repositories FeedbackRepository.cs Add project references (Internal references)
Add dependencies in src API Core Infrastructure Swashbuckle.AspNetCore Core Newtonsoft.Json If any shared nuget packages comes here Infrastructure Core Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection -Version 8.1.1 Install-Package Microsoft.EntityFrameworkCore -Version 6.0.9 Install-Package Microsoft.EntityFrameworkCore.SqlServer -Version 6.0.9 Install-Package Microsoft.EntityFrameworkCore.Design -Version 6.0.9 Uninstall-Package Microsoft.EntityFrameworkCore.Design -Version 6.0.9 Add dependencies in test FeedbackService.Api.Tests FeedbackService.Api FeedbackService.Core.Tests FeedbackService.Core FeedbackService.Infrastructure.Tests FeedbackService.Infrastructure Add model in infra called Feedback.cs
Create DbContext classes & register in startup
Create model in Core - Feedback.cs
Create interface in Core - IFeedbackRepository.cs
Create interface’s implementation in Infra - FeedbackRepository.cs
Configure dependencies for repos
Create Service interface & classes – IFeedbackService & FeedbackService
Create Service classes - FeedbackService
Create controller classes – FeedbackController
What is AutoMapper? AutoMapper is a simple library that helps us to transform one object type to another. It is a convention-based object-to-object mapper that requires very little configuration.
The object-to-object mapping works by transforming an input object of one type into an output object of a different type.
One Use Case AutoMapper was built to solve a complex problem that most developers face in their day-to-day life – writing code that maps one object type to another. This type of code is rather tedious and boring to write, so why not leave that job to this little tool?
What makes AutoMapper interesting is that it provides some easy to use conventions to take the dirty work out of figuring out how to map Type A to Type B. As long as Type B follows AutoMapper’s established conventions, almost no configuration is needed to map two types.
Here’s one common scenario. We’ve created an application and we want to keep the separation between our domain models and our view models.
In order to accomplish this, we need to write the code to adapt our domain model to our view model. Then, as we add more views and domain models, we end up writing more adapters. Later on, we’ll have to write even more adapters to map our data transfer objects from the database layer into our domain objects.
This is mundane and repetitive. And this is where AutoMapper comes in.
How to Use AutoMapper in Our Application Let’s have a look at how to add Automapper into our .NET Core application.
Installation The first step is to install the corresponding NuGet package:
Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection