Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix A: A Brief Overview of GoF Design Patterns

We all have unique thought processes. So, in the early days of software development, engineers faced a common problem—there was no standard to instruct them on how to design their applications. Each team followed its own style, and when a new member (experienced or inexperienced) joined an existing team, understanding the architecture was a gigantic task. Senior or experienced members of the team would need to explain the advantages of the existing architecture and why alternative designs were not considered. The experienced developer also would know how to reduce future efforts by simply reusing the concepts already in place. Design patterns address this kind of issue and provide a common platform for all developers. You can think of them as the recorded experience of experts in the field. Patterns were intended to be applied in object-oriented designs with the intention of reuse.

In 1994, Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides published the book Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley, 1994). In this book, they introduced the concept of design patterns in software development. These authors became known as the Gang of Four. I refer to them as the GoF throughout this book. The GoF described 23 patterns that were developed by the common experiences of software developers over time. Nowadays, when a new member joins a development team, the developer is expected to know about the design patterns, and then the developer learns about the existing architecture. This approach allows a developer to actively participate in the development process within a short period of time.

The first concept of a real-life design pattern came from the building architect Christopher Alexander. During his lifetime, he discovered that many of the problems he faced were similar. So, he tried to address those issues with similar types of solutions.

Each pattern describes a problem, which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.
—Christopher Alexander

The software engineering community started believing that though these patterns were described for buildings and towns, the same concepts can be applied to patterns in object-oriented design. So, they felt that we could substitute the original concepts of walls and doors with objects and interfaces. The common thing in both fields is that, at their cores, patterns are solutions to common problems.

It is important to note that the GoF discussed the original concepts of design patterns in the context of C++. But C# 1.0 was released in 2002, and then it went through various changes. It grew rapidly and secured its rank in the world’s top programming languages within a short time, and in today’s market, it is always in high demand. At the time of this writing, C# 8.0 is available with Visual Studio 2019. The concepts of design patterns are universal. The book is written in C#, but if you are familiar with any other popular programming languages such as Java, C++, and so on, you can relate because I primarily focus on the design patterns and not on the latest features of C#. I purposely chose simple examples to help you understand these concepts easily. Exercising these fundamental concepts of design patterns using C# always make you a better programmer and help you to reveal an upgraded version of you. The following are some important points to remember.

A design pattern describes a general reusable solution to software design problems. When developing a software application, you may encounter these problems frequently. The basic idea is that you can solve similar kinds of problems with similar kinds of solutions. And these solutions were tested over a long period of time.
Patterns provide you a template of how to solve a problem and can be used in many different situations. At the same time, they help you to get the best possible design much faster.
Patterns are descriptions of how to create objects and classes and customize them to solve a general design problem in a particular context.

The GoF discussed 23 design patterns. Each of these patterns focuses on object-oriented design. Each pattern can also describe the consequences and trade-offs of use. The GoF categorized these 23 patterns based on their purposes, as shown next.

A.
Creational Patterns
These patterns abstract the instantiation process. You make the systems independent from how their objects are composed, created, and represented. In these patterns, you should have a basic concern: “Where should I place the new keyword in my application?” This decision can determine the degree of coupling of your classes. The following five patterns belong in this category.
- Singleton pattern
- Prototype pattern
- Builder pattern
- Factory Method pattern
- Abstract Factory pattern

B.
Structural Patterns
Here you focus on how classes and objects can be composed to form a relatively large structure. They generally use inheritance or composition to group different interfaces or implementations. Your choice of composition over inheritance (and vice versa) can affect the flexibility of your software. The following seven patterns fall into this category.
- Proxy pattern
- Decorator pattern
- Adapter pattern
- Facade pattern
- Flyweight pattern
- Composite pattern
- Bridge pattern

C.
Behavioral Patterns
Here you concentrate on algorithms and the assignment of responsibilities among objects. You also need to focus on the communication between them and how the objects are interconnected. The following 11 patterns fall into this category.
- Visitor pattern
- Observer pattern
- Strategy pattern
- Template Method pattern
- Command pattern
- Iterator pattern
- Memento pattern
- State pattern
- Mediator pattern
- Chain of Responsibility pattern
- Interpreter pattern

The GoF made another classification based on scope, namely whether the pattern primarily focuses on the classes or its objects. Class patterns deal with classes and subclasses. They use inheritance mechanisms, so, these are static and fixed at compile time. Object patterns deal with objects that can change at run time. So, object patterns are dynamic. Factory Method pattern, Interpreter pattern,and Template Method pattern can be classified as class patterns. Remaining patterns of the GoF can fall into object patterns. It is interesting to note that depending on the implementation,an Adapter pattern can fall in both category.

Note

In this book, each chapter is self-contained, and you can start with any pattern you like following the guidelines given at the beginning of the book. I use simple examples so that you can pick up the basic ideas quickly. But you must read, digest, and practice, and try to link to other problems and keep coding. This process will help you to master the subject quickly.

Q&A Session

A.1 What are the differences between class patterns and object patterns ?

In general, class patterns focus on static relationships, but object patterns can focus on dynamic relationships. Class patterns focus on classes and subclasses, and object patterns focus on an object’s relationships.

Table A-1 shows the summarized content that was discussed in the GoF’s famous book.

Table A-1

Class Patterns vs Object Patterns

	Class Patterns	Object patterns
Creational	Can defer object creation to its subclasses	Can defer object creation to another object
Structural	Focuses on the composition of classes (primarily uses the concept of inheritance)	Focuses on the composition of objects
Behavioral	Describes algorithms and execution flows; uses inheritance mechanism	Describes how different objects work together to complete a task

A.2 Can I combine two or more patterns in an application?

Yes. In real-world scenarios, this type of activity is common.

A.3 Do these patterns depend on a particular programming language ?

Programming languages can play an important role. But the basic ideas are the same, patterns are just like templates, and they give you an idea in advance of how you can solve a problem. In this book, I primarily focused on object-oriented programming with the concept of reuse. But instead of any object-oriented programming language, suppose you have chosen some other language like C. In that case, you may need to think about the core object-oriented principles such as inheritance, polymorphism, encapsulation, abstraction, and so on, and how to implement them. So, the choice of language is always important because it may have some specialized features that can make your life easier.

A.4 Should I consider the common data structures like arrays, linked lists also as different design patterns?

The GoF excludes those saying that they are not complex, domain-specific designs for an entire application or subsystem. They can be encoded in classes and reused as-is. So, they are not your concern in this book.

A.5 If no particular pattern is 100% suitable for my problem, how should I proceed?

An infinite number of problems cannot be solved with a finite number of patterns for sure. But if you know these common patterns and their trade-offs, you can pick a close match. Lastly, no one prevents you from using your own pattern for your own problem. But you must tackle the risk, and you need to think about your return on investment.

A.6 Do you have any general advice before I jump into the topics?

I always follow the footsteps of my seniors and teachers who are experts in this field. And here are some of their general suggestions.

Program to a supertype (Abstract class/Interface), not an implementation.
Prefer composition over inheritance in most cases.
Try to make a loosely coupled system.
Segregate the code that is likely to vary from the rest of your code.
Encapsulate what varies.

A.7 How do I use this book effectively?

This book focuses on commonly used design patterns. Most likely, you will face them very often in your everyday life. But the world is always changing, and new patterns keep evolving. To understand the necessity of a new pattern, you may also need to understand why an old/existing pattern is not enough to fulfill the requirement. You may consider this book as an attempt to make a solid foundation with design patterns so that you can move smoothly in your professional life, and you can adapt to the upcoming changes easily.

Appendix B: Useful Resources

This following is a list of useful resources . Many of them use a different programming language, but you will benefit from reading these great books.

Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma et al. (Addison-Wesley, 1995)
Head First Design Patterns by Eric Freeman and Elisabeth Robson (O’Reilly, 2004)
Java Design Patterns by Vaskaran Sarcar (Apress, 2018)
Design Patterns for Dummies by Steve Holzner
(Wiley Publishing, Inc., 2006)
C# Design Pattern Essentials by Tony Bevis (Ability First Limited, 2012)
Design Patterns in C# by Jean Paul (Kindle edition, 2012)

The following are helpful online resources/websites .

Appendix C: The Road Ahead

Congratulations! You have reached the end of this journey. Anyone can start a journey, but only a few can complete it with care. So, you are among the minority who possess the extraordinary capability to cover the distance successfully. I hope that you have enjoyed your learning experience. If you continue to think about the discussions, examples, implementations, and the Q&A Sessions in this book, you will have more clarity, you will feel more confident about the content, and you will remake yourself as a programmer.

Truly, a more detailed discussion on any design pattern would require this book to be too big to digest. So, what is next? You should not forget that learning is a continuous process. This book attempts to encourage in-depth learning of its core concepts.

I believe that only learning and thinking by yourself is not enough. I suggest you participate in open forums and join discussion groups to get more clarity on this subject. This process will not only help you; it will help others also.

Lastly, I have a request. You can always point out the areas for improvement, but at the same time, please let me know what you liked about this book too. In general, it is always easy to criticize, but an artistic view and an open mind are required to discover the true efforts that are associated with any work.

Thank you, and happy coding!

Appendix D: Important Updates in the Second Edition

This second edition offers descriptive class diagrams and more code explanations in every chapter. Table D-1 lists the most important updates in this edition.

Table D-1

The Most Important Updates in This Edition

Pattern Name	Key Update (or Inclusion)
Singleton	Additional implementation using a single lock, Lazy<T>.
Prototype	Additional implementation for shallow vs. deep copy.
Builder	Additional implementation using method chaining.
Factory Method	Shorter and concise implementation; one improved version is added (using method parameters).
Abstract Factory	Implementation fine-tuned and modified.
Proxy	Additional code explanation with Q&A is added.
Decorator	Implementation modified with more code explanation.
Adapter	Implementation fine-tuned; a complete example of class adapter is added.
Facade	Implementation made shorter and fine-tuned with additional explanations.
Flyweight	Implementation modified with extrinsic and intrinsic states. A factory class is implemented as a singleton to show an alternative design of this pattern.
Composite	Implementation fine-tuned with additional property (designation) and more code explanation.
Bridge	An additional implementation is added.
Visitor	Replaced the first implementation with a better one (extended in the Q&A session), and following the same design, fine-tuned the second implementation using both the Visitor and the Composite patterns.
Observer	Implementation fine-tuned; Now you see multiple celebrities with multiple observers.
Strategy	Better example provided; Q&A session is enhanced.
Template Method	Implementation fine-tuned with more Q&A.
Command	Old programs are replaced with new programs; additional explanation for undo, logging, and so forth are included.
Iterator	An additional program using C#’s built-in support for iterators is included.
Memento	One new implementation using nested class is included. Q&A session is enhanced.
State	More Q&A and explanation are added.
Mediator	Minor modification to the programs in previous edition of the book. Now these programs have both send and receive logic. Additional explanations are added.
Chain of Responsibility	Old program is modified. More code explanation with a real-life example is added .
Interpreter Pattern	One new implementation is added in this chapter. First demo is a fine-tuned version from previous edition of the book.
Simple Factory	Old program is replaced with a shorter and more concise implementation.
Null Object Pattern	More explanation (including null conditional operator) is added. Q&A session is enhanced.
MVC	The Winform application is replaced with a console application.
Asynchronous Programming	This is a new chapter in this book.
Criticism to Design Patterns	More information is added.
Antipatterns	Enhanced with history, types, and examples of antipatterns.
FAQ	Fine-tuned with additional questions and answers.

Index

AboutMe() method

AboutTriangle() method

Abstract keyword

Abstract class

Abstract creator class

AbstractDecorator class

AbstractExpression

Abstract Factory pattern

challenges

concept

vs. factory method pattern

factory of factories

GoF definition

IAnimalFactory

IDog and ITiger interfaces

implementation

class diagram

demonstration

solution explorer view

real-world and computer-world example

vs. simple factory pattern

structure

WildAnimalFactory

Abstract prototype

Action delegate

Adaptee interface method

Adapter pattern

concept

drawbacks

GoF definition

implementation

class adapter, demo

class diagram

demonstration

IRectangle interface

IRectangle methods

Main() method

Rectangle hierarchy

solution explorer view

real-world and computer-world example

Adapters

AddHeadlights()

Aggregate

AnimalFactory

Antipatterns

causes

concepts

design pattern

examples

history

overview

real-world application development

solutions

symptoms

types

Architectural antipatterns

ArrayList

async and await Keywords

async and await keywords

AsyncCompletedEventHandler

Asynchronous callback

Asynchronous programming patterns

IAsyncResult

SeeIAsyncResult pattern

lambda expression with ThreadPool class

overview

synchronous approach

thread class

ThreadPool class

AsyncWaitHandle of IAsyncResult

AuthenticationErrorHandler

Behavioral patterns

Boat class object

Bridge pattern

advantages

approach

challenges

class diagram

concept

concrete implementor

demonstration

designs

ElectronicGoods, demo

GoF definition

hierarchies

implementation

abstraction class

class diagram

constructors

demonstration

ElectronicGoods

GetDiscount(int percentage) method

OnlinePrice class

Television class

implementor method

programming

real-world and computer-world example

solution explorer view

subclassing

BuildBody()

Builder pattern

abstract class

advantages

complex object

complex objects, creation

drawbacks associated

GoF definition

implementation

analysis

class diagram

demonstration

Director class

IBuilder interface

solution explorer view

modified implementation

analysis

characteristics

class diagram

demonstration

IBuilder

Product class

solution explorer view

real-world and computer-world example

separate class, director

CalculateArea() methods

CalculateAreaOfTriangle()

Callback method

CarFactory class

Chain of responsibility pattern

advantages

challenges

concept

GoF definition

implementation

class diagram

demonstration

EmailErrorHandler

error handler objects

FaxErrorHandler

Receiver class

segments of code

solution explorer view

UnknownErrorHandler

message priorities

vs. Observer pattern

real-world and computer-world scenario

Class adapter design pattern

Client object

Clone() method

Command object

Command pattern

advantages

concept

disadvantages

GoF definition

implementation

class diagram

encapsulation

ExecuteCommand() method

GameStartCommand

interface ICommand

program, demo

solution explorer view

undo() method

modified implementation

demonstration

invoker

UpLevel() and DownLevel()

real-world and computer-world scenario

Composite design

Composite pattern

advantages

concept

disadvantages

GoF definition

implementation

class diagram

CompositeEmployee class

demonstration

DisplayDetails()

solution explorer view

tree structure, organization

Iterator design pattern

real-world and computer-world example

Composition

ConcreteAggregate

ConcreteBuilder object

ConcreteHome

ConcreteIterator

ConcreteMediator class

Concrete prototypes

ConcreteSubject object

ConcreteSubject instance

Construct() method

ConstructRobot()

Context class

ContinueWith() method

Copy constructor

CreateAnimal() method

Creational patterns

CurrentItem() method

Data structures

Decorator pattern

advantages

concept

disadvantages

dynamic binding

GoF definition

implementation

AbstractDecorator

class diagram

concrete decorator

ConcreteHome

demonstration

FloorDecorator and PaintDecorator

PaintDecorator

solution Explorer view

inheritance

real-world and computer-world example

Decorators

Deep copy

Design pattern

Design pattern criticisms

DestroyRobot() method

DestroyRobotBody

Details() method

Development antipatterns

Dictionary object

Discount() method

DisplayCourseStructure() method

DisplayDetails() method

DisplayEnrolledEmployees()

DogFactory and TigerFactory

DoSomeWork()

Double-checked locking

DoubleDiscount() method

DownLevel() method

ElectronicGoods abstraction class

EmailErrorHandler

EndInvoke method

EndOperations()

Event-based asynchronous pattern (EAP)

analysis

characteristics

demonstration

message box pops up

pros and cons

runtime screenshot, UI application

UI application

WebClient

ExecuteCommand() method

ExecuteMethodOne()

ExecuteMethodThree() method

ExecuteMethodTwo()

ExecuteTaskOne()

Experience reuse

Extrinsic

Facade class static

Facade pattern

vs. adapter design pattern

advantages

challenges

complex subsystem

compositions

concept

GoF definition

implementation

class diagram

demonstration

RobotBody and RobotColor

RobotBody class

RobotColor class

solution explorer view

real-world and computer-world example

Factory Method pattern

Abstract keyword

advantages

challenges

concept

GoF definition

implementation

class diagram

demonstration

solution explorer view

modified implementation

analysis

AnimalFactory class, demo

CreateAnimal(), demo

parallel class hierarchies

real-world and computer-world example

Simple Factory pattern

FactoryProvider

FaxErrorHandler

First() method

FloatBehavior

FloorDecorator

FlyBehavior

Flyweight pattern

advantages

challenges

concept

extrinsic data

GoF definition

implementation

AboutMe() method

analysis

class diagram

demonstration

FutureVehicle

GetRandomColor()

intrinsic state

solution explorer view

VehicleFactory

intrinsic data

multithreading

object creations

real-world and computer-world example

vs. Singleton pattern

VehicleFactory

Func delegate

FutureVehicle

Game class constructor

GameStartCommand class

GameStartCommand command

GetEnumerator() method

GetRandomColor()

GetVehicle() method

GiveThanks() method

GoF design patterns

behavioral patterns

creational patterns

fundamental concepts

structural patterns

Graphical user interface (GUI)

Handle/Body pattern

Hierarchical inheritance

I, J, K

IAnimalFactory

IAsyncCallback delegate

IAsyncResult pattern

Asynchronous Callback

AsyncWaitHandle

polling, asynchronous delegates

IBuilder interface

ICelebrity interface

IEnumerable interface

IIterator

Immutable objects

IncludeAdditionalPaper()

InsertWheels()

Interpreter pattern

advantages

challenges

concept

GoF definition

implementation

class diagram

Context class

EvaluateInputWithContext

demonstration

InputExpression abstract class

solution explorer view

modified implementation

class diagram

concrete classes

Context class constructor

demonstration

Employee interface method

rule validator

solution explorer view

real-world and computer-world scenario

structure

Intrinsic

Invoke() method

IObserver interface

IPossibleStates

IPrice interface

IRectangle interface

IRectangle methods

IsCollectionEnds()

Iterator object

Iterator

Iterator pattern

challenges

concept

diagram

GoF definition

implementation

built-in constructs, demo

class diagram

CurrentItem() method

demonstration

First() method

IsCollectionEnds()

Next() method

solution explorer view

real-world and computer-world scenario

ITriangle interfaces

IVisitor

Lambda expression

Lambda expression with ThreadPool class

Lazy instantiation process

Lazy<Singleton>

Lazy<T> class

Locking mechanism

Loose coupling

Main() method

MakeAnimal()

MakeHome() method

MakeRobotBody()

MakeSingletonInstance() method

Management antipatterns

Mediator pattern

advantages

challenges

concept

vs. Facade pattern

GoF definition

implementation

AbstractFriend

analysis

class diagram

ConcreteMediator class

demonstration

Friend class

IMediator

solution explorer view

Stranger class

modified implementation, demonstration

participants

real-world and computer-world scenario

MemberwiseClone() member method

MemberwiseClone() method

Memento pattern

advantages

concept

disadvantages

GoF definition

implementation

class diagram

CurrentMemento() and RestoreMemento(…)

demonstration

memento class

Originator object

solution explorer view

undo operations

modified implementation

class diagram

client code

demonstration

solution explorer view

real-world and computer-world scenario

undo operations

Message priorities

Method1Delegate

Method chaining

MobileDeviceView

Model-view-controller (MVC) pattern

advantages

architecture

challenges

components

concept

definition

framework

implementation

AddEmployeeToModel(Employee employee)

applications

class diagram

demonstration

DisplayEnrolledEmployees()

IModel, IView, and IController

RemoveEmployeeFromModel(string employeeIdToRemove) methods

Solution Explorer view

modified output

modified solution explorer view

real-world and computer-world scenario

variations

Multithreading

myDel()

myFuncDelegate()

MyInt static variable

MyMethod()

Next() method

Nonshareable flyweight interface

NonterminalExpression

System.NullReferenceException

Null Object pattern

analysis

challenges

Command pattern

concept

definition

faulty program

implementation

analysis

class diagram

demonstration

NullVehicle object

solution explorer view

output with valid input

potential fix

proxies

real-world and computer-world scenario

structure

unwanted input analysis

use cases

NullVehicle class

NullVehicle object

Online resources/websites

Object adapters

Object creations

Object-oriented programming (OOP)

Object patterns

Object Pool pattern

Observer pattern

advantages

and Chain of Responsibility pattern

challenges

concept

GoF definition

implementation

Celebrity class

class diagram

demonstration

ICelebrity interface

IObserver interface

solution explorer view

one-to-many relationships

real-world and computer-world scenario

OnlinePrice class

Organizational antipatterns

Originator.Memento

PaintDecorator

Pattern Languages of Program Design (PLoP)

PetAnimalFactory

Product class

Programming language

Protection proxies

Prototype pattern

abstract method

advantages

challenges

class diagram

GoF definition

implementation

analysis

CarFactory

demonstration

instance, creation

modified implementation

real-world and computer-world example

solution explorer view

structure

user-defined copy constructor

Proxies

Proxy pattern

concept

ConcreteSubject instance

disadavantage

GoF definition

implementation

class diagram

ConcreteSubject

demonstration

DoSomeWork()

solution explorer view

modified implementation

proxies, types

real-world and computer-world example

use cases

public static member

Publisher-Subscriber (Pub-Sub) model

QueueUserWorkItem method

Rectangle class

Rectangle hierarchy

Refactoring

RemoteControl

Remote proxies

Return on investment (ROI)

RobotBody class

RobotColor class

RobotFacade class

Run() method

Send() method

SetAdditionalPrice()

SetColor()

SetVehicleBehavior(…) method

Shallow Copy vs. Deep Copy

analysis

characteristics, program

demonstration

Simple Factory pattern

challenges

concept

definition

implementation

characteristics

class diagram

demonstration

solution explorer view

object’s creation

real-world and computer-world scenario

static class

Single responsibility

Singleton class

Singleton pattern

alternative implementation

approach, modeling

code segment

double-checked locking

GoF definition

implementation

analysis

characteristics

class diagram

demonstration

solution explorer view

instance

locking mechanism

Main() method

object creations

real-world scenario

sealed keyword

Singleton class

thread pool, multithreading environment

use cases

Smalltalk’s automatic forwarding mechanism

Smart reference

SpecialPaper() method

StartNew() method

StartUpOperations()

State pattern

advantages

concept

dynamic Strategy pattern

GoF definition

implementation

class diagram

demonstration

ExecuteMuteButton()

ExecuteOffButton()

ExecuteOnButton()

IPossibleStates

solution explorer view

states of TV

open/close principle

real-world and computer-world scenario

states of TV

vs. Strategy pattern

Static class

Static initialization

Strategy pattern

advantages

concept

disadvantages

FloatBehavior

FlyBehavior

GoF definition

implementation

class diagram

context class

demonstration

FloatBehavior

SetVehicleBehavior(…) method

solution explorer view

inheritance

real-world and computer-world scenario

Structural patterns

Subsystem classes

Synchronous approach

System.NullReferenceException

Target interface

Task-based asynchronous pattern (TAP)

async and await Keywords

ContinueWith() method

demonstration

ExecuteMethodOne() and ExecuteMethodTwo()

Run() method

TaskContinuationOptions

TaskCreationOptions

Tasks

Television class

Template Method pattern

advantages

modified BasicEngineering class

behavioral design pattern

concept

disadvantages

Electronics class

GoF definition

implementation

BasicEngineering abstract class

class diagram

ComputerScience class

demonstration

DisplayCourseStructure() method

solution explorer view

modified implementation

real-world and computer-world scenario

vs. Strategy pattern

TerminalExpression

Thread class

ThreadPool class

TotalObjectsCreated property

TResult parameter

Triangle. IRectangle interface

undo() method

UnknownErrorHandler

Updates

UpLevel() method

User-defined copy constructor

User Interface antipatterns

Vehicle context class

VehicleFactory factory class

Virtual proxies

Visitor pattern

abstract class

vs. composite pattern

drawbacks associated

encapsulation

GoF definition

implementation

AddNumberToList(…)

class diagram

demonstration coding

IncrementNumberVisitor

numberList

RemoveNumberFromList(…) method

SmallNumber

solution explorer view

UndefinedNumber

VisitBigNumbers(..) and VisitSmallNumbers(..)

inheritance hierarchy

open/close principle

operation

overloading method

real-world and computer-world scenario

SmallNumber and BigNumber class

use cases

W, X, Y, Z

WaitOne() method

WildAnimalFactory

Windows Presentation Foundation (WPF)

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Table of Contents for
Back Matter