ASP.NET Core - SOLID and Clean Architecture
What you'll learn
- Implement SOLID Principles
- ASP .NET Core Blazor and API Development
- Advanced Tools - MediatR, Automapper, Fluent API and Validation
- Custom Exceptions and Global Error Handling
- Custom .NET Core Middleware
- Using NSwag and NSwag Studio
- Use Swagger for API Documentation
- Implement CQRS Pattern
- Use Identity and JWT To Secure Application API
- Build API Client Secure Application
- Moq and Shouldly Frameworks
- Unit Testing
- At least three months of C# Development
- A Computer
- A Willingness to Learn
Creating a modular, testable, and maintainable application in .NET Core requires a solid foundation. Setting up an application architecture requires foresight and much consideration, as early decisions will impact how easily the application is extended and maintained.
In the long run, though, applications need to be maintained and, in this case, extended. Between its design and the way the code was written, neither is possible, so the application needs to be redesigned and future-proofed.
Why SOLID Architecture?
When we talk about SOLID architecture, what we refer to isn’t a straightforward task. Decisions made early in the process can have a large impact later on, and maintainability and testability play an important role. Adopting these practices can also contribute to avoiding code smells, refactoring code, and facilitating more efficient agile development.
SOLID stands for:
S - Single-Responsibility Principle
O - Open-closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle
In this course, you explore foundational architectural principles which help with the creation of maintainable code. You will discover how to set up a real-world application architecture with ASP.NET Core. Then, you’ll learn how to plug in different, common blocks such as email and authentication and have a foundation to plug-in other third-party services as needed.
Everything in this course is .NET 6 / .NET 7 compatible.
When you finish this course, you’ll have the skills and knowledge to create a testable and maintainable ASP.NET Core application to architect real-world enterprise .NET Core apps.
N.B. - The project in this course is based on the deliverables in Complete ASP.NET Core and Entity Framework Development. While it is not mandatory to do this course, much of the existing code will be reused from this course's content.
Build A Strong Foundation in .NET Clean Architecture:
Learn Clean or Onion Architecture and Best Practices
Learn Command Query Responsibility Segregation (CQRS)
Implement Mediatr Pattern
Add Email Service using SendGrid
Efficient Exception Handling and Routing
Implementing Unit Testing
Moq and Shouldy
Global Error Handling with Custom Middleware and Exceptions
Adding Validation Using Fluent Validation
Build a .NET Core API and Blazor UI Application
Implement JWT(JSON Web Token) Authentication
Content and Overview
To take this course, you must have some knowledge of .NET Core development and C#.
This is a huge course. Over 10 hours of premium content, but smartly broken up to highlight related activities based on each module in the application being built. We will also look at troubleshooting and debugging errors as we go along; implementing best practices; writing efficient logic, and understanding why developers do things the way they do. Your knowledge will grow, step by step, throughout the course, and you will be challenged to be the best you can be.
We don't do things the perfect way the first time; that is different from the reality of writing code. We make mistakes and point them out and fix them around them. By doing this, we develop proficiency in using debugging tools and techniques. By the time you have finished the course, you will have moved around in Visual Studio and examined logic and syntax errors so much that it will be second nature for you when working in the .NET environment. This will put your newly learned skills into practical use and impress your boss and coworkers.
The course is complete with working files hosted on GitHub, including some files to make it easier for you to replicate the demonstrated code. You will be able to work alongside the author as you work through each lecture and will receive a verifiable certificate of completion upon finishing the course.
Clicking the Take This Course button could be the best step you could take towards quickly increasing your income and marketability! Also, remember that if you don't think the course is worth what you spent, you have a full 30 days to get a no questions asked refund!
It's time to take action!
See you in the course!
Who this course is for:
- Late Beginner to Intermediate Programmers
Trevoir Williams is a passionate software and system engineer with a strong drive to share the best of his knowledge with students around the globe. His educational achievements include a Master’s degree in Computer Science (major in Software Development) and several Microsoft Azure Certifications.
His impressive work experience includes software consulting, software engineering, database development, cloud system, and server administration, lecturing, and he’s also a musician!
Trevoir enjoys teaching IT and development skills and guides students in gaining the latest knowledge with practical application in the modern industry.