Index

As this ebook edition doesn't have fixed pagination, the page numbers below are hyperlinked for reference only, based on the printed edition of this book.

A

abstract classes 351, 391

Abstract Factory pattern 97-103

abstract syntax trees (ASTs) 300

abstraction 40

access methods

getter 343

setter 344

access modifiers

about 341

adding 342

internal 342

private 342

private protected 342

protected 342

protected internal 342

public 342

Active Domain Object (ADO) pattern 312

ActiveX Data Objects (ADO) 312

Ada 329

Adapter pattern 292-294

Adobe Illustrator 341

aggregations 399

Agile development 260

aliases 333

ampere (amp) 229

application programmer interface-(API-) 140

arrays 325

artificial intelligence (AI) 296

aspect-oriented programming (AOP) 315

association 399

B

Behavioral patterns 173

bicycle

CAD design 74-79

initial design 79-87

Bicycle class 127, 128

bicycle project, patterns

behavioral patterns 233

creation patterns 232

structural patterns 232

Big Ball of Mud 9, 10

Big Ball of Mud, forces

change 12

complexity 12

cost 11

experience 11

scale 12

skills 11

time 11

visibility 12

bill of materials (BOM) 276

bit 332

blue screen of death (BSOD) 326

booleans 324

Bridge pattern

about 158-166, 242, 243

implementing 167

reviewing 160

use case 166

used, for painting wheelchair 283-287

broken windows theory 35

Builder interface 106

Builder pattern 103-112, 127, 235, 236

Builder pattern, Wheelchair

concrete component classes, adding 276

implementing 270-274

setting up 279-281

WheelchairComponents folder, refactoring 274, 275

Bumble Bikes factory 214-216

C

C#

auto-implemented properties 344

automated garbage collection 326

automatic bounds checking 324-325

background 321

design goals 321

detection, for uninitialized variables 324, 325

general-purpose language 321, 323

highly portable code 326-327

language mechanics 327-329

purely and fully object-oriented 323

type system 323, 324

variables 329, 330

Chain of Responsibility pattern 296, 297

character type 333

class

about 334-337

constructor 337, 338

decorating 131

instantiation 337

methods 339, 340

name 337

namespaces 336

parts 336

properties 339

using statements 336

class diagram

about 73, 388-391

abstract classes 391

constructor 392, 393

designing, without all details 393, 394

enumerations 395, 396

interfaces 394

packages 396

required types diagramming 392

structures 388, 389

clean code

characteristics 42

cognitive load, limiting 46

commenting 48

consistency, enforcing 46

consistency, establishing 46

style, enforcing 46

style, establishing 46

terse 47, 48

writing 41

writing, readable by humans 42-46

client-server 36

client-server pattern 310

cloning 291

cloud computing 36

CMYK color model 158, 283

code reviews

about 66, 67

functionality 68

overall design 67, 68

cognitive load 46

Collections 334

command-line programs 356

Command pattern

about 173, 244-246

applying 175

code, testing 180

coding 176-179

components 174, 175

Command Query Responsibility Segregation (CQRS) pattern 311

commercial off-the-shelf (COTS) components 140

Common Intermediate Language (CIL) 327

Common Object Request Broker Architecture (CORBA) 141

Composite pattern

about 148-152, 157, 237-241

finishing up 268, 269

implementing 152-156

composition 41, 398, 399

computer-aided design (CAD) 218

concrete component classes, Plano Wheelchair

about 276

axles 276

casters 276

frames 277

seats 277

wheels 278, 279

constructor

about 337, 338, 392, 393, 396

aggregations 399

association 399

composition 398, 399

dependency 400

directed association 400

inheritance 397

interface realization 397

Continuous Integration (CI) 46

controller layer 310

creatine kinase (CK) 215

Creational patterns 73

D

data 323

Data Access Object (DAO) 312

Data access patterns

about 311

Active Domain Object (ADO) pattern 312

demand cache 312

optimistic lock 313

ORM 311, 312

pessimistic lock 313

transaction 312

Data Definition Language (DDL) 20

Data Manipulation Language (DML) 22

Decorator pattern

about 127-136, 314

ConcreteComponent 129

ConcreteDecorator1 129

ConcreteDecorator2 129

Decorator 129

IComponent 129

working 136-138

decoupling 61

deep copying 290

demand cache 312

dependency 400

Dependency Injection (DI) 62

Dependency Inversion Principle (DIP) 61-65

directed association 400

Director class 106

Document Object Model (DOM) 300

domain-specific languages (DSLs) 290

Don’t Repeat Yourself (DRY) 43, 223, 272

duck typing 330

E

Electric Light Orchestra (ELO) 213

encapsulation

about 40, 340, 341

accessor logic, with backing variables 346, 347

enumerations 81, 395, 396

European Computer Manufacturers Association (ECMA) 321

F

Façade pattern

about 139-142

BuffingAPI 143

GrabbingAPI 143

implementing 143-147

RobotArmFacade class 143

WelderAttachmentAPI class 143

factory class 89

Factory Method pattern 91-97

first-in, first-out (FIFO) 182

FixComponent() method 264-267

Flyweight pattern 294, 295

frame 226

functional programming

versus OOP 323

G

Gang of Four (GoF) software design patterns 211, 323

Generics 334

god function 49

Golden Hammer 12-15

I

IDEs, for C# development

about 355

Rider 378

Visual Studio 356

VS Code 367

implicit typing 330

inheritance

about 40, 347, 397

working 347-351

Inkscape 341

instantiation 73, 337

intent 314

interface realization 397

interfaces

about 41, 351, 352, 394

defining 352-354

implementing 354, 355

Interface Segregation Principle (ISP) 59-61

Internet of Things (IoT) 64, 141

Interpreter pattern 290

introspection 365

inventory management systems (IMSs) 313

Inversion of Control (IoC) 62

iterative development 260

Iterator pattern

about 181-183

applying 184

coding 185-191

implementing 191, 192

J

JavaScript Object Notation (JSON) 28

Java Virtual Machine (JVM) 321

K

keeping it working 10

L

lasagna code 36-40

Liskov Substitution Principle (LSP) 55-58

M

Maverick wheelchair 218, 219, 225

Mediator pattern 300, 301

memento 313

Memento pattern 289, 302-304

methods 339

Microservices pattern 310

Microsoft Disk Operating System (MS-DOS) 356

Microsoft Intermediate Language (MSIL) 321

minimum viable product (MVP) 260

model layer 310

Model-View-Controller (MVC) pattern 310

Monodevelop 356

N

namespaces 336

No pattern implementation 87-89

notes 401

NuGet 21

numbers 324, 330

O

Object-Oriented Design (OOD) 49

object-oriented programming (OOP) language 327

versus functional programming 323

object pool pattern 112-117

Object-Relational Mapper (ORM) 21, 142, 310-312

objects 328

Observer pattern

about 192-194

applying 195

coding 195-199

Open-Closed Principle (OCP) 51-55, 400

optimistic lock 313

organic light-emitting diode (OLED) 216

original equipment manufacturer (OEM) 8

P

packages 396

patterns

about 30, 289

Adapter pattern 292, 293

adding 232, 233

Chain of Responsibility pattern 296, 297

designing with 217-220

design meeting 233, 234

first pass 220-224

Flyweight pattern 294, 295

Mediator pattern 300, 301

Memento pattern 302-304

need for 29-31

Prototype pattern 290, 291

Proxy pattern 298, 299

second pass 234, 235

state pattern 304-307

Visitor pattern 308, 309

patterns, elements

name and classification 313

problem description 314

solution description 314, 315

using, consequences 315

patterns, first pass

battery, for powered wheelchair 229

casters 227, 228

frame 226

motor, for powered wheelchair 228

seat 225, 226

steering mechanism, for powered wheelchair 229

track drive system, for Texas Tank 230-232

wheels 227, 228

peer-to-peer (P2P) architecture 310

pessimistic lock 313

physical rehabilitation clinic 217

piecemeal growth 10

Plano Wheelchair 219, 225

polymorphism 40

PoweredChair class 222

powered wheelchair

battery 229

motor 228

steering mechanism 229

primitive data types 324, 332

programming idiom 91

properties 328

Prototype pattern 290, 291

Proxy pattern 298, 299

publish-subscribe (pub-sub) pattern 310

Q

quality

defining 66

measuring 66

quality assurance (QA) 213, 296

quaternions 177

R

random-access memory (RAM) 294

ravioli code 40, 41

Red Green Blue (RGB) color model 158

Representational State Transfer (REST) 141, 300

Resharper 378

Rider

about 378

class, adding 380, 381

command-line project, creating 379, 380

console project, building 385

console project, running 385

interface, adding 380, 381

library project, creating 381-383

library project, linking to console project 383, 384

linked library, testing 384, 385

Roslyn 365

S

seat 225, 226

separation of concerns (SoC) 36, 310

SharpOS 323

signed numeric types 330-332

signed type 331

Simple Factory pattern 89, 90

Simple Object Access Protocol (SOAP) 141

Single Responsibility Principle (SRP) 49-51, 296

singleton 313

Singleton pattern

about 117-122, 236

adding 281, 282

SmallTalk 323

snapshot 302

software architecture patterns

about 310

client-server pattern 310

Command Query Responsibility Segregation (CQRS) pattern 311

Microservices pattern 310

Model-View-Controller (MVC) pattern 310

publish-subscribe (pub-sub) pattern 310

software development kit (SDK) 298

software evolution

explained with pasta 35

SOLID principles

Dependency Inversion Principle (DIP) 61-65

Interface Segregation Principle (ISP) 59-61

Liskov Substitution Principle (LSP) 55-58

Open-Closed Principle (OCP) 51-55

Single Responsibility Principle (SRP) 49-51

used, for creating maintainable systems 49

spaghetti code 35

Stack Overflow 47

State pattern 304-306

static type system 324

Stock Keeping Unit (SKU) 165

Stovepipe system

about 7-9

exploring 8, 9

Strategy pattern

about 199-202

applying 202

coding 203-206

strings 333, 324

strongly typed language 330

strong type system 324

Structured Query Language (SQL) 13, 311, 322

StyleCop 46

T

technical debt 8

Template Method pattern 306, 307

Texas Tank

about 217

designing, with patterns 217-220

track drive system 230-232

throwaway code

about 10

example 15-29

tiers 36

transaction 312

type system 323

U

UML class diagrams

best practices 401-405

Unified Modeling Language (UML) 7, 39, 126, 293

Unity 3D 326

unsigned types 331

US Department of Defense (DoD) 329

user experience (UX) 310

using statements 336

V

variables, C# 329, 330

view layer 310

Visitor pattern 308, 309

Visual Basic 355, 356

Visual Basic for Applications (VBA) 14

Visual Studio

about 356

class, adding 361, 362

command-line project, creating 357-361

console project, building 365-367

console project, running 365-367

editions 356

library project, adding to solution 362, 363

library project, linking to console project 363, 364

library, referencing 364, 365

Visual Studio Community 357

Visual Studio Enterprise 357

Visual Studio Professional 357

Volatile Organic Compounds (VOCs) 165

VS Code

.NET Core, installing 368

about 367

C# extension, adding 373, 374

class, adding 374, 375

code, adding to BicycleLibrary project 375-377

command-line project, creating 370, 371

console project, building 377, 378

console project, running 377, 378

download link 368

interface, adding 374, 375

launching 373

library, linking to console project 373

library project, creating 372

solution, creating 368-370

W

weakly typed language 330

weak type system 324

whatever-as-a-service (WaaS) 13

Wheelchair

base classes 268

class 221

components 259-267

composite pattern, finishing up 268, 269

painting, with Bridge pattern 283-287

project, setting up 252-259

wrapper 314

X

Xamarin Studio 356

Y

You Ain’t Gonna Need It (YANGI) 68, 224