Design Patterns using C# and .NET Core

It’s fairly common for developers to write classes that do more than one thing.

• Demonstrate an example of such a class
• Refactor the class to adhere to the single responsibility principle

The open/closed principle is rarely used as developers keep adding stuff to their classes.

• Describe what closed to modification means
• Explain what open to extension means
• Demonstrate a comprehensive example

The Liskov substitution principle is perhaps the hardest of the five. We need to provide a high quality explanation without making the video long and boring.

• Theoretical examination
• Use a quiz app example

According to the interface segregation principle, a class shouldn’t be forced to implement a method that it does not need or can’t implement.

• Go straight to an example of an interface that is wrongfully used
• Split that interface into two interfaces
• Implement them separately

Dependency Inversion is so vital that a part of it, Dependency Injection will have its own section. But for now we need to demonstrate how important it is.

• Explain Dependency Inversion and loose coupling in theory
• Demonstrate tight coupling’s downsizes
• Implement a service the correct way by connecting to an abstraction

In this video, we will work almost exclusively with patterns so introductions are in order.

• Describe design patterns in general
• Briefly explain each creational pattern that we are going to study

Sometimes we need to only have a single instance of a class.

• Describe singleton theoretically
• Implement singleton with a PrimaryPlayer class
• Note limitations and downsides

Following the single responsibility principle, our consumer classes shouldn’t be the ones responsible for knowing how to instantiate classes that we need.

• Describe the factory pattern in theory
• Create an EnemyFactory

We need to take care of a few stuff in the course project. This presents a nice opportunity to involve the concept of Loose Coupling.

• Create an Iweapon interface
• Create different weapon implementations
• Add them to the player and attack an enemy

The Object Pool is a great pattern to avoid having to be constantly initializing our enemy classes every time we need them.

• Modify the EnemyFactory to work with object pools
• Create a pool for the Zombie class
• Add a reclaim mechanism

Not all C# developers are familiar with Dependency Injection and since we are dedicating a whole section on it we better spend a video trying to explain the most interesting topics.

• Explain Dependency Injection thoroughly
• Show a very simplistic visual example

There’s great value in creating a Custom IoC Container. The viewer will get to understand the inner workings of Dependency Injection.

• Describe the vital operations that an IoC Container needs to be doing
• Implement the registration method
• Implement the Dependency resolution method

The Custom Container is good for educational purposes but we need something more robust. So we have to move on to the built-in ASP.NET Core IoC Container.

• Create an ICardsService interface
• Create a CardsService concrete implementation
• Register the implementation as a Singleton and inject it to a controller

The ASP.NET Core Container offers three different registration strategies. We need to make the distinctions clear.

• Describe the three strategies and decide on the best one for the task at hand
• Create a method that tests the API connection
• Consume the API project from the console application

Sometimes we want to combine objects while maintaining their types. To do that we use the decorator pattern.

• Use figures to explain what the decorator pattern does
• Use the decorator pattern to decorate cards with items

We must make use of a foreign interface. We need to make it work with what we already have. That’s what the adapter pattern is for.

• Introduce a 3rd party library to the project
• Work with the adapter pattern to circumvent it

The Gameboard class is getting more and more complicated.

• Theoretical introduction to the facade pattern
• Use the facade pattern to simplify the Gameboard

We want to provide a way to iterate through decks of cards as well as decks of decks.

• Describe the composite pattern
• Create a common IComposite interface

We want to quickly and easily fetch data from the API in a loosely coupled way.

• Decouple the service from the implementation
• Use a proxy class to fetch the data

Sometimes we need to choose an algorithm at runtime. The strategy pattern is perfect at doing that.

• Describe the need for the strategy pattern
• Create two strategies for showing messages

Watching the primary player’s health is better than just using strategy.

• Create a HealthChanged event
• Register observers
• Combine them with the strategy pattern

We need a way to encapsulate the battles between players and enemies as well as cards and enemies.

• Create an ICommand interface
• Create two command implementations
• Group them into a list and execute

The template method defines an abstract base class that forces sub-classes to only implement part of the functionality.

• Create a template for rendering the battlefield
• Create different battlefields that will be randomly generated

The state pattern offers a convenience class to store data about your sessions.

• Create a state class
• Store statistics there