C# Application Practices


C# Application Practices

Authors: Matthew Renze, Jeremy Clark, Zoran Horvat, Vladimir Khorikov

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


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

by Matthew Renze

Jan 11, 2017 / 2h 20m

2h 20m

Start Course

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.

This course is 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
  1. Course Overview
  2. Introduction
  3. Domain-centric Architecture
  4. Application Layer
  5. Commands and Queries
  6. Functional Organization
  7. Microservices
  8. Testable Architecture
  9. Evolving the Architecture

Getting Started with Dependency Injection in .NET

by Jeremy Clark

Mar 5, 2019 / 2h 8m

2h 8m

Start Course

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
  1. Course Overview
  2. What Is Tight Coupling and How Does It Impact Your Applications?
  3. Using Dependency Injection to Build Loosely-coupled Applications
  4. Taking Advantage of Loose Coupling
  5. How Dependency Injection Makes Unit Testing Easier
  6. 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

by Zoran Horvat

Oct 19, 2016 / 7h 4m

7h 4m

Start Course

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
  1. Course Overview
  2. Attaining Extensibility with Object-oriented Code
  3. Rendering Branching Over Boolean Tests Obsolete
  4. Keeping the Focus on Domain Logic with Sequences
  5. Untangling Structure from Operations on Business Data
  6. Turning Algorithms into Strategy Objects
  7. Using Immutable Objects When Possible
  8. Leveraging Special Case Objects to Remove Null Checks
  9. Turning Optional Calls into Calls on Optional Objects
  10. Increasing Flexibility by Avoiding Switch Statements
  11. Turning Chained Branching into the Chain of Rule Objects
  12. Refactoring to Bind It All Together

Applying Functional Principles in C#

by Vladimir Khorikov

Apr 8, 2016 / 3h 28m

3h 28m

Start Course

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
  1. Course Overview
  2. Introduction
  3. Refactoring to an Immutable Architecture
  4. Refactoring Away from Exceptions
  5. Avoiding Primitive Obsession
  6. Avoiding Nulls with the Maybe Type
  7. Handling Failures and Input Errors in a Functional Way
  8. Putting It All Together