Skip to content
An example of how to implement various clean coding & architecture techniques. Technologies used: .Net Core, Razor Pages, EF Core, Bootstrap 4
Branch: master
Clone or download
Tillman32 Fixed bug in ArticleEntity.cs
The DTO was being refrenced in the entity model
Latest commit 7073d33 May 19, 2019
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
src Fixed bug in ArticleEntity.cs May 19, 2019
.gitattributes Update .gitattributes Apr 10, 2019
.gitignore .gitignore updates Apr 10, 2019
CleanArchitecture.sln Moved project structure into src/test - added more to README Apr 10, 2019
LICENSE Create LICENSE May 4, 2018
README.md Update README & cleanup May 2, 2019

README.md

License: MIT

The motivation behind it all

What is the point of all this? Well, besides showcasing Bob Ross... I thought it would be clever to have a "real world" application to reference when talking architecture. I want something to set a standard, something to clone, something to utilize in all my next .Net Core projects. Like all software (and wine), this will improve with time.

I also found it fitting, that "Uncle Bob" (Robert C. Martin) shares a similar name, and this project makes an attempt to align with his architecture outlined here on his website.

An example of the application running on AWS (Ubuntu) is hosted here: https://cleanarchitecture.brandontillman.com

I also wrote a blog post to pair with it here: https://www.brandontillman.com/clean-architecture-dot-net-core/

Key Points:

🔱 N-Tier Architecture

A 3 layered approach, to set us up for multiple UI's that use the same core business functionality/back-end. 

📂 Separation of Concerns

Closely related to the "Single Responsibility" principle, Separation of Concerns (SoC) makes your code more maintainable, by not co-locating ideas. When things change, SoC will help ensure your changes are limited to your feature set, and not spread throughout your application.

💧 No Leaky Abstractions

By using interfaces, we can avoid leaky abstractions, and have better control of how our code is used. On the contrary, consumers of our code don't have to know the implementation details, they can simply use your interfaces/classes.

🔬 Testable

Testing code that is tightly coupled is nearly impossible. By following the SOC principal, and using interfaces our code will be easier to rest in result.

🔌 Modular

The code will be easier to modify in the future, because of a few reasons. Separation of concerns allows for fewer changes/testing throughout the application. You can build on specific feature sets, without modifying the rest of the code.

🔧 Maintainable

The code will inherently be more maintainable by following Clean Architecture patterns. Other developers will see the benefit of the clean separation, and follow suit.

Technologies Used

🌟 Give it a Star!

If you like or are using this project to learn or start your solution, please consider giving it a star. Thank you!

You can’t perform that action at this time.