Paths
C# Application Practices
After you have mastered the fundamentals of the C# language, you will be challenged to build larger and more complex applications. This skill path is designed to equip you with... Read more
What you will learn
- Techniques for code organization
- Common application architectures
- Dependency injection
- Advanced object-orientated programming
- Functional programming techniques
- Patterns for handling concurrency
Pre-requisites
Knowledge of the C# programming language and some knowledge of object-oriented programming principles
Application Design Principles
To start off with, you will learn about common architecture patterns for C# applications and how to make use of them. Then, you will take a dive into dependency injection, one of the most commonly used design techniques in use today in .NET applications.
Clean Architecture: Patterns, Practices, and Principles
2h 21m
Description
Hello, and welcome to Pluralsight! My name is Matthew Renze, and I want to give you a quick overview of my course, Clean Architecture: Patterns, Practices, and Principles. It’s designed to help you learn how software experts keep their architecture clean using a modern approach to software architecture called Clean Architecture, and covers things like domain-centric architecture, application layers, CQRS (Command-Query Responsibility Separation), event sourcing, functional cohesion, bounded contexts, and more. In addition, you'll use these practices to replace the outdated three-layer database-centric architecture that has been used for decades. Most important though, you'll see how these practices, when combined, create an architecture that is simple, understandable, flexible, testable, and maintainable. When you’re done, you’ll have the skills necessary to understand and implement these clean architecture practices on your own software projects.
As an introductory course, there are no prerequisites for this course. However, having basic experience with at least one C like programming language, and basic knowledge of software architecture will be beneficial.
I look forward to working with you on Clean Architecture: Patterns, Practices, and Principles, here at Pluralsight.
Table of contents
- Course Overview
- Introduction
- Domain-centric Architecture
- Application Layer
- Commands and Queries
- Functional Organization
- Microservices
- Testable Architecture
- Evolving the Architecture
Getting Started with Dependency Injection in .NET
2h 9m
Description
Tight coupling makes our code hard to change and test. In this course, "Getting Started with Dependency Injection in .NET", you will learn the foundational knowledge to break tight coupling with Dependency Injection. First, you will learn how to use constructor injection to create loosely-coupled code. Next, you will see how to snap those loosely-coupled pieces together in different ways to easily change functionality. Then, you will discover how easy it is to unit test code that uses dependency injection. Finally, you will explore some of the magic of dependency injection containers. When you are finished with this course, you will have the skills and knowledge of dependency injection needed to break tight coupling and write more maintainable code.
Table of contents
- Course Overview
- What Is Tight Coupling and How Does It Impact Your Applications?
- Using Dependency Injection to Build Loosely-coupled Applications
- Taking Advantage of Loose Coupling
- How Dependency Injection Makes Unit Testing Easier
- Dependency Injection Containers
C# Programming Paradigms
The course in this section are designed to expose you to the different programming paradigms available in C#, including how to apply sophisticated object oriented principles and how to take advantage of ideas from functional programming in C#
Making Your C# Code More Object-oriented
7h 5m
Description
Programmers do have conceptual understanding of OO concepts, but often fail to turn that into a proper object-oriented code. In this course, Making Your C# Code More Object-oriented, you'll learn how to create proper object-oriented code. First, you'll learn how to avoid branching and looping. Next, you'll learn how to avoid Boolean expressions. Finally, you'll learn how to make domain logic implementation dynamic and configurable. By the end of this course, you'll be able to recognize your own error of the past and build more correct coding style.
Table of contents
- Course Overview
- Attaining Extensibility with Object-oriented Code
- Rendering Branching Over Boolean Tests Obsolete
- Keeping the Focus on Domain Logic with Sequences
- Untangling Structure from Operations on Business Data
- Turning Algorithms into Strategy Objects
- Using Immutable Objects When Possible
- Leveraging Special Case Objects to Remove Null Checks
- Turning Optional Calls into Calls on Optional Objects
- Increasing Flexibility by Avoiding Switch Statements
- Turning Chained Branching into the Chain of Rule Objects
- Refactoring to Bind It All Together
Applying Functional Principles in C#
3h 28m
Description
With the advent of LINQ, C# has gotten a significant exposure to functional programming. However, functional programming in C# is not restricted to the use of extension methods, lambdas and immutable classes. There are a lot of practices that haven't been adopted as widely because there's not much of native language support for them in C#. Still, they can be extremely beneficial should you incorporate them into your day-to-day work. This course, Applying Functional Principles in C#, will show them to you. You will learn the fundamental principles behind functional programming, why they are important and how to apply them in practice. Specific topics you'll cover include refactoring to an immutable architecture, avoiding exceptions, primitive obsession, how to handles failures and input errors, and more. By the end of this course, you will have a much more comprehensive understanding of why and how to use functional programming.
Table of contents
- Course Overview
- Introduction
- Refactoring to an Immutable Architecture
- Refactoring Away from Exceptions
- Avoiding Primitive Obsession
- Avoiding Nulls with the Maybe Type
- Handling Failures and Input Errors in a Functional Way
- Putting It All Together