Clean_Architecture_Program_Generator_for_CSharp_and_NET6_Solution 1.6.7

Clean Architecture Solution Program Generator

Program Generator to generate Clean Architecture base project structure solution containing Repositories, Services and Controllers.

Table of Contents

• Getting Started
• Installed Files
  • Clean Architecture Database Access Generator.tt
  • Clean Architecture WebAPI Generator.tt
  • T4Helper.ttinclude
• Github Link
• Installing template from Nuget Package Manager
• How to check if this really works
  • Adding new entities
    • Code First approach
    • Database First approach
• Some useful commands

Getting Started

This is a NuGet package should be installed as a template in dotnet cli.
You can browse this package using manage NuGet packages by searching for "Thomson Mathews" or "Clean_Architecture_Program_Generator_for_CSharp_and_NET6"

This will install two template files in your project.
Clean Architecture Database Access Generator.tt
Clean Architecture WebAPI Generator.tt

Once these template files are installed.

Run the all templates using "Transform All T4 Templates" from the build menu.

or Run individual template by right click on the template and select "Run Custom Tool"

This will generate the following projects.

Now define entities in the Domain Project using code first approach or database first approach
and run the transformation again.

Voila! all repositories, services and controller are generated for you by the templates.

Now just set WebAPI as a startup project and run it, that's it.

Clean Architecture Database Access Generator.tt

This template will generate 4 projects:
Domain, Application, Persistence, Startup.

Domain Project:
Define all entities in Entities folder, either using code first approach or database approach, Exceptions folder defines some basic useful exceptions that can be used in global error handling, Interface folder contains GenreicRepository, RepositoryManager and UnitOfWork interfaces that is implemented in the Persistence project.

Application Project
Defines Interface for ServiceManager in the Interfaces folder, will also generate repository interface for each entity defined in the Domain project. ServiceManger is implemented in the Services Folder, it will also contain Services for each entities defined in the Domain project.

Persistence Project:
ApplicationDbContext should be defined or generated using Entity Framework in the context folder, Repositories folder contains GenericRepository, RepositoryManager and UnitOfWork implementation.

Modify AddPersistenceExtension class to refer to correct connection string.

Startup Projects:
This is a console application that will create a Generic Host which will help in dependency injection, here ApplicationDbContext is added to the ServiceCollection, this project will help you to run Entity framework commands to do entity migrations to a database or generate entities and ApplicationDbContext from existing database.

Startup project is only used to run Entity framework commands with out a WebAPI project and is not required if WebAPI project is generated.

Once you add more entities, you can run this template again to generate repository interfaces for the new Entities in the Domain Project, repository implementation for the new Entities in Persistence Project and Services and its Service interfaces for the new Entities in the Application Project.

Clean Architecture WebAPI Generator.tt

This template will generate open a dialog box, select ASP.NET Core WebAPI project and it will create a project named WebAPI

WebAPI Project:
This contains controllers and other required classes.

Controller Folder:
Contains generated controller for each entities defined in Domain project.

Extensions Folder:
Contains extension method to add BasicAuthMiddleware to the HTTP request pipeline.

MiddleWare Folder:
Contains implementation for BasicAuthMiddleware and ExceptionHandlingMiddleware.

Appsetting.json:
Contains configuration for Serilog logging, connection string and basic authentication details.

Appsetting Folder:
Contains classes structures to read from appsettings.json file.

Program.cs This connect all the wiring between the projects.

Once you add more entities, you can run this template again to generate controllers for the new Entities in the WebAPI Project.

T4Helper.ttinclude

This file contains function used by the above T4Template files.

Github Link

https://github.com/tcj2001/Clean_Architecture_Program_Generator_for_CSharp_and_NET6

Installing template from Nuget Package Manager

From your package manager console.
dotnet new -i Clean_Architecture_Program_Generator_for_CSharp_and_NET6_Solution
This will add a new template in your dotnet cli environment.

dotnet new -l
you can use the above command to check if the template was installed.

CA_PG_C#_NET6_SOL is shortname for the template

There are two way to use the template.

First Method.
Go to a directory where you want to make use of the template and type command.
dotnet new CA_PG_C#_NET6_SOL -o YourProjectFolderName

This will create a ClassLibrary project named Clean_Architecture_Program_Generator_for_CSharp_and_NET6 within the solution

Second Method.
When you select new project in visual studio you will see a template named Clean_Architecture_Program_Generator_for_CSharp_and_NET6, if you don't see filter the project type and select Clean Architecture, select this template and create your project.

This will create a ClassLibrary project named Clean_Architecture_Program_Generator_for_CSharp_and_NET6 within YourProjectFolderName.

How to check if this really works

Once all the projects are generated using the T4Templates
By default Domain project will contains one entity named Sample.cs, it also generated Repository and Services for sample entity.
The classes highlighted in green will get generated for each entity defined in the Domain project entities folder.
The Classes highlighted in red gets re-generated every time with entity details.

Code First approach

Since we already have a sample entity defined for you by the template, I will just make use of it.
Just for simplicity let's create a SQLite database to hold a table for Sample entity in app.db by running these commands.
dotnet ef migrations add "initialmigration2" --project Persistence --startup-project WebAPI
dotnet ef database update --project Persistence --startup-project WebAPI

This will create App.db in WebAPI folder with a table named Sample.

In the appsettings.json we already have two connections string pre-defined.

Make sure class AddPersistenceExtension in Persistence project has
services.AddDbContext<ApplicationDbContext>(options ⇒ options.UseSqlite("Name=SqliteDb"));

Set WebAPI as a startup project and run it.

Database First approach

Here we will make use of a BookStores database in my Sql Server setup. This database was grabbed from internet, credit goes to the person who made it available for community.

Make sure class AddPersistenceExtension in Persistence project has
services.AddDbContext<ApplicationDbContext>(options ⇒ options.UseSqlServer("Name=SqlServerDb"))

Run this command with a connection string pointing to your Sql Server Database.
scaffold-DbContext -Connection "Name=SqlServerDB" -Provider Microsoft.EntityFrameworkCore.SqlServer -Project Persistence -StartupProject WebAPI -OutputDir ..\Domain\Entities -Context ApplicationDbContext -ContextDir ..\Persistence\Context -Namespace Domain.Entities -ContextNamespace Persistence.Context -DataAnnotations -force

This will generate all entities in domain project

Run all templates

or individual template

All repositories, services and controllers are generated for you.

Set WebAPI as a startup project and run it.

By default the WebAPI uses BasicAuthentication the userid and password is defined in the appsettings.json file

Some useful commands

Code First Migrations
dotnet ef migrations add "initialmigration1" --project Persistence --startup-project Startup
dotnet ef migrations add "initialmigration2" --project Persistence --startup-project WebAPI

dotnet ef database update --project Persistence --startup-project Startup
dotnet ef database update --project Persistence --startup-project WebAPI

Database First Migrations
scaffold-DbContext -Connection "Server=DESKTOP-GBANT4V; Database=BookStoresDB; Trusted_Connection=True;" -Provider Microsoft.EntityFrameworkCore.SqlServer -Project Persistence -StartupProject Startup -OutputDir ..\Domain\Entities -Context ApplicationDbContext -ContextDir ..\Persistence\Context -Namespace Domain.Entities -ContextNamespace Persistence.Context -DataAnnotations -Force

If possible do not use connection string directly in the above command.

if you have an appsettings.json define connection strings as shown
"ConnectionStrings": { "SqliteDB": "DataSource=app.db;Cache=Shared", "SqlServerDB": "Server=DESKTOP-GBANT4V; Database=BookStoresDB; Trusted_Connection=True;" }
then use "Name=SqliteDB" in the scaffold-DbContext -Connection parameter

Remove migration
dotnet ef migrations remove

List migrations
dotnet ef migrations list

Install entity frame work
dotnet tool install --global dotnet-ef
dotnet tool update --global dotnet-ef

Create a solution with the current director name
dotnet new solution

Create a startup project if webapi or mvc not used
dotnet new worker -n Startup

Create class library
dotnet new classlib -o projectName

Add solution file
dotnet sln add SomeFolder/SomeProject.csproj AnotherFolder/AnotherProject.csproj

Add project dependency
dotnet add SomeFolder/SomeProject.csproj reference AnotherFolder/AnotherProject.csproj

Add package dependencies
dotnet add SomeFolder/SomeProject.csproj package microsoft.entityframeworkcore