ĐẠI HỌC FPT CẦN THƠ

Design Pattern in .NET

Lession 5
 Objectives

◆ Overview about Design Pattern

◆ Why must use Design Pattern?

◆ Explain about Singleton Pattern

◆ Explain about Factories Pattern

◆ Explain about Abstract Factory Pattern

◆ Explain about Builder Pattern

◆ Explain about Prototype Pattern

◆ Demo about Factories Method, Prototype Pattern and

Singleton Pattern in .NET applications

Lession 5: Design Pattern in .NET - Huong Hoang Luong 2

 Understanding Design Patterns

A design pattern provides a general reusable solution for the

common problems that occur in software design

A design pattern isn't a finished design that can be transformed

directly into code. It is a description or template for how to solve
a problem that can be used in many different situations

Design patterns are programming language independent

strategies for solving a common problem. That means a design
pattern represents an idea, not a particular implementation

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Understanding Design Patterns

Design patterns are not meant for project development. Design patterns are
meant for common problem-solving and whenever there is a need, we have
to implement a suitable pattern to avoid such problems in the future

The pattern typically shows relationships and interactions between classes or

objects

By using the design patterns we can make our code more flexible, reusable,
and maintainable

The Gang of Four (GoF) patterns are generally considered the foundation for
all other patterns. They are categorized in three groups: Creational,
Structural, and Behavioral

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Why use Design Pattern?

◆ Design patterns can speed up the development process

by providing tested, proven development paradigms
◆ Effective software design requires considering issues that

may not become visible until later in the implementation

◆ Reusing design patterns helps to prevent subtle issues

that can cause major problems and improves code

readability for coders and architects familiar with the
patterns

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Why use Design Pattern?

Often, we only understand how to apply certain software design

techniques to certain problems. These techniques are difficult to apply to a
broader range of problems. Design patterns provide general solutions,
documented in a format that doesn't require specifics tied to a particular
problem

Patterns allow developers to communicate using well-known, well

understood names for software interactions. Common design patterns can
be improved over time, making them more robust than ad-hoc designs

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Introduction to GoF Patterns

Behavioral Design Patterns:

Chain of responsibility,
Structural Design Patterns:
Command, Interpreter,
Adapter, Bridge, Composite,
Creational Design Patterns Iterator, Mediator, Memento,
Decorator, Facade, Flyweight,
Null Object, Observer, State,
Private Class Data, and Proxy
Strategy, Template method and
Visitor

While class-creation patterns

These patterns can be further use inheritance effectively in Creational design patterns are
These design patterns are all
categorized into Class- the instantiation process, the Singleton, Factory Method,
about class instantiation or
creational patterns and object- object-creation patterns use Abstract Factory, Builder, and
object creation
creational patterns delegation effectively to get the Prototype
job done

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Creational Design Patterns

The following five patterns are concerned with the

instantiation of objects:
• Singleton: A pattern for enforcing only one instance of a class
• Factory Method: A pattern for creating objects derived from a
class where the specific class is determined at runtime
• Abstract Factory: A pattern for the creation of objects belonging
to a family of classes. The specific object is determined at
runtime
• Builder: A useful pattern for more complex objects where the
construction of the object is controlled externally to the
constructed class
• Prototype: A pattern for copying or cloning an object
Lession 5: Design Pattern in .NET - Huong Hoang Luong
 ĐẠI HỌC FPT CẦN THƠ

Singleton Pattern
 Singleton Pattern

◆ Defines an Instance operation that lets clients access its unique instance. Instance is a
class operation
◆ Responsible for creating and maintaining its own unique instance

◆ Make the class of the single instance responsible for access and "initialization on
first use". The single instance is a private static attribute. The accessor function is a
public static method

Lession 5: Design Pattern in .NET - Huong Hoang Luong 10

 Implement Singleton Pattern

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Implement Singleton Pattern

Lession 5: Design Pattern in .NET - Huong Hoang Luong 12

 ĐẠI HỌC FPT CẦN THƠ

Factories Method Pattern

 Factories Method Pattern

◆ Factory method related to object creation. Define an

interface for creating an object, but let subclasses decide
which class to instantiate
◆ Factory Method lets a class defer instantiation to

subclasses
◆ In Factory pattern, we create object without exposing

the creation logic to client and the client use the same
common interface to create new type of object
◆ The idea is to use a (static)member-function or

(static)factory method which creates and returns

instances, hiding the details of class modules from user

Lession 5: Design Pattern in .NET - Huong Hoang Luong 14

 Factories Method Pattern

◆ A factory pattern is one of the core design principles to create an object, allowing
clients to create objects of a library in a way such that it doesn’t have tight coupling
with the class hierarchy of the library

UML class diagram

Lession 5: Design Pattern in .NET - Huong Hoang Luong 15

 Implement Factories Method

UML class diagram

Lession 5: Design Pattern in .NET - Huong Hoang Luong 16

 Implement Factories Method

Lession 5: Design Pattern in .NET - Huong Hoang Luong 17

 Implement Factories Method

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Implement Factories Method

Lession 5: Design Pattern in .NET - Huong Hoang Luong 19

 ĐẠI HỌC FPT CẦN THƠ

Abstract Factory Pattern

 Abstract Factory Patterns

Abstract Factory patterns work around a super-factory which

creates other factories. This type of design pattern comes
under creational pattern as this pattern provides one of the
best ways to create an object

In Abstract Factory pattern an interface is responsible for

creating a factory of related objects without explicitly
specifying their classes. Each generated factory can give the
objects as per the Factory pattern

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Abstract Factory Design Pattern
Participants

AbstractFactory: declares an interface for operations that create abstract

products

ConcreteFactory: implements the operations to create concrete product

objects

AbstractProduct: declares an interface for a type of product object

Product: defines a product object to be created by the corresponding

concrete factory and implements the AbstractProduct interface

Client: uses interfaces declared by AbstractFactory and AbstractProduct

classes

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 UML class diagram

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 ĐẠI HỌC FPT CẦN THƠ

Builder Pattern
 Builder Pattern

Builder pattern aims to “Separate the construction of a

complex object from its representation so that the same
construction process can create different representations.”

It is used to construct a complex object step by step and the

final step will return the object

The process of constructing an object should be generic so

that it can be used to create different representations of the
same object

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Builder Design Pattern Participants

Product – The product class defines the type of the complex object that is to be
generated by the builder pattern.

Builder – This abstract base class defines all of the steps that must be taken in
order to correctly create a product. Each step is generally abstract as the actual
functionality of the builder is carried out in the concrete subclasses. The
GetProduct method is used to return the final product. The builder class is often
replaced with a simple interface

ConcreteBuilder – There may be any number of concrete builder classes

inheriting from Builder. These classes contain the functionality to create a
particular complex product

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Builder Pattern

◆ Director – The director class controls the algorithm that

generates the final product object. A director object is
instantiated and its Construct method is called. The
method includes a parameter to capture the specific
concrete builder object that is to be used to generate the
product. The director then calls methods of the concrete
builder in the correct order to generate the product
object. On completion of the process, the GetProduct
method of the builder object can be used to return the
product

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Builder Pattern

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Advantages of Builder Design Pattern

The parameters to the constructor are reduced and are provided in highly
readable method calls

Builder design pattern also helps in minimizing the number of parameters

in constructor and thus there is no need to pass in null for optional
parameters to the constructor

Object is always instantiated in a complete state

Immutable objects can be build without much complex logic in object

building process

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Disadvantages of Builder Design
Pattern
◆ The number of lines of code increase at least to double
in builder pattern, but the effort pays off in terms of
design flexibility and much more readable code
◆ Requires creating a separate ConcreteBuilder for each

different type of Product

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 ĐẠI HỌC FPT CẦN THƠ

Prototype Pattern
 Prototype Pattern

◆ The prototype allows us to hide the complexity of

making new instances from the client
◆ The concept is to copy an existing object rather than

creating a new instance from scratch, something that

may include costly operations
◆ The existing object acts as a prototype and contains the

state of the object

◆ The newly copied object may change the same

properties only if required. This approach saves costly

resources and time, especially when object creation is a
heavy process

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Prototype Pattern

Prototype patterns are required, when object creation is

a time-consuming, and costly operation, so we create an
object with the existing object itself

One of the best available ways to create an object from

existing objects is the clone() method

Clone is the simplest approach to implement a

prototype pattern. However, it is our call to decide how
to copy existing object based on your business model

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Prototype Design Pattern Participants

◆ Prototype: This is the prototype of the actual object

◆ Prototype registry: This is used as a registry service to have all prototypes accessible using simple
string parameters
◆ Client: The client will be responsible for using the registry service to access prototype instances

34

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Implement Prototype Pattern

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Implement Prototype Pattern

Lession 5: Design Pattern in .NET - Huong Hoang Luong

 Implement Prototype Pattern

37

Lession 5: Design Pattern in .NET - Huong Hoang Luong

38

Summary

◆ Concepts were introduced:

▪ Overview about Design Pattern in .NET
▪ Why must use Design Pattern?
▪ Explain about Singleton Pattern
▪ Explain about Factories Pattern
▪ Explain about Abstract Factory Pattern
▪ Explain about Builder Pattern
▪ Explain about Prototype Pattern
▪ Demo about Factories Method, Prototype Pattern and Singleton Pattern in .NET applications

Lession 5: Design Pattern in .NET - Huong Hoang Luong

ĐẠI HỌC FPT CẦN THƠ