Here Development is all only once but can be used in any type with any level of easy expansion with ReUsable & Shared Components with Advanced Security of data & api. Example Provided MyTown usecase,like that anyne can replace or extend easily upto any level.

• Type1: Blazor WebAssembly Stnadalone(PWA+Offline) Client(Static App) & ASP Dotnet Core Clean Architecture Api (For less cost consumption due to Static WebApp Deployment )

• Type2: Blazor WebAssembly Stnadalone(PWA+Offline) Client Hosted on ASP Dotnet Core Clean Architecture Api Single Project Deployment (For Advanced with Easy Deployment Just like Api deployment specifically in advanced case)

• Type3:(Adding Sooner) Blazor WebApp With Auto Render Modes (For Advanced Sensitive cases)

• Api & Backend

• Blazor WebAssembly CLient & ReUsable components

• Together Shared Project structure as below,

• Detailed Diagram

• Request Anonymous, Authentication Flow

Forked & inspired from many other Good projects Globally, I additionally adding improvements with Blazor Standalone Webassembly client & making completely disconnected architecture implementation with features,

Social accounts login & Jwt

Same Jwt token using for validation with API calls with id_Tokens & validation

For new users dynamically creates AspNet Identity Account & more

Razor Class Library & Component based reusable architecture in multi-layered projects

Fluxor Redux Pattern

IExceptionHandler implemetnation of dotnet 8

IP Rate limiting on API to secure attacks

Only API Side configuration & dynamically load those to client webassembly without hardcoded client Appsettings for security concern

CLient side only api url first time ,reamining all fetching from API dynamically

Offline Db with Blazored.localstorage

More necessary features will be adding sooner like Auto refresh... Authentication & made Apis only responded to dedicated cleints using AppKey & Interceptors logic, will share the details soon but code & fully working code is in place.

On Top Of Base Branch more contents adding here for improvement

0> make changes in domains 1> Set API project as startup project(must be only one startup project,if api & client both startup then it creates issue ) 2> then specific commands like any of below

• add-migration baseEntityChanges -Context ApplicationDbContext -project CleanArchitecture.Infrastructure.Persistence
  • update-database -Context ApplicationDbContext
• add-migration baseEntityChanges -Context FileManagerDbContext -project CleanArchitecture.Infrastructure.FileManager
  • update-database -Context FileManagerDbContext
• add-migration baseEntityChanges -Context IdentityContext -project CleanArchitecture.Infrastructure.Identity
  • update-database -Context IdentityContext

Below is mostly forked contents with default of ONLY API focused:

An Implementation of Clean Architecture with ASP.NET Core 8 WebApi. With this Open-Source BoilerPlate Template, you will get access to the world of Loosely-Coupled and Inverted-Dependency Architecture in ASP.NET Core 8 WebApi with a lot of best practices.

The following prerequisites are required to build and run the solution:

• .NET 8.0 SDK (latest version)

The easiest way to get started is to install the .NET template:

dotnet new install Sam.CleanArchitecture.Template

You should see the template in the list of templates from dotnet new list after this installs successfully. Look for "ASP.NET Clean Architecture Solution" with Short Name of "ca-api".

Navigate to the parent directory in which you'd like the solution's folder to be created.

Run this command to create the CleanArchitecture project

dotnet new ca-api -n MyProjectName

The MyProjectName directory and solution file will be created, and inside that will be all of your new solution contents, properly namespaced and ready to run/test!

1. Create new UseCase
2. Create New Entity
3. Create New Resource
4. Easy Add Migration Tools

Download the Extension and install it on your machine. Make sure Visual Studio 2022 is installed on your machine with the latest SDK.

Follow these Steps to get started.

You Solution Template is Ready with default as below!

Next, open the appsettings.json file in WebAPI to modify the ConnectionStrings if necessary.

Finally, build and run the Application.

As soon you build and run your application, default users and roles get added to the database.

Default Roles are as follows.

• Admin

Here are the credentials for the default users.

• UserName - Admin / Password - Sam@12345

You can use these default credentials to generate valid JWTokens at the ../api/v1/Account/Authenticate endpoint.

Does it really make sense to Setup your ASP.NET Core Solution everytime you start a new WebApi Project ? Aren't we wasting quite a lot of time in doing this over and over gain?

This is the exact Problem that I intend to solve with this Full-Fledged ASP.NET Core 8 WebApi Solution Template, that also follows various principles of Clean Architecture.

The primary goal is to create a Full-Fledged implementation, that is well documented along with the steps taken to build this Solution from Scratch. This Solution Template will also be available within Visual Studio 2022 (by installing the required Nuget Package / Extension).

Demonstrate Clean Monolith Architecture in ASP.NET Core 8

• This is not a Proof of Concept
• Implementation that is ready for Production
• Integrate the most essential libraries and packages

If you found this Implementation helpful or used it in your Projects, do give it a star. Thanks!

• ASP.NET Core 8 WebApi
• REST Standards
• Blazor Standalone WebAssembly Client
• Fluxor/Redux
• Serilog
• Rate limiting
• Social Account login & Jwt validation of API also
• MudBlazor

• Clean Architecture
• CQRS with MediatR Library
• Entity Framework Core - Code First
• Repository Pattern - Generic
• Serilog
• Swagger UI
• Response Wrappers
• Healthchecks
• Pagination
• Microsoft Identity with JWT Authentication
• Role based Authorization
• Identity Seeding
• Database Seeding
• Custom Exception Handling Middlewares
• API Versioning
• Localization (fa / en)
• Fluent Validation
• Complete User Management Module (Register / Authenticate / Change UserName / Change Password)
• User Auditing
• TestProjects
  • FunctionalTests
  • UnitTests
  • IntegrationTests

• Visual Studio 2022 Community and above
• .NET Core 8 SDK and above
• Basic Understanding of Architectures and Clean Code Principles
• Blazor Knowledge

I have personally not come across any existing clean implementation of ReUsable & Extendable Blazor options with WebAPI, which is the reason that I started building this up. There are quite a lot of improvements and fixes along the way from the day I started out. Thanks to the community for the support and suggestions. Please share this Repository within your developer community, if you think that this would a difference! Thanks.

If any issue or Questions Please raise!!!