- Contents
- Introduction
- Acknowledgments
- 1 Why Pattern?
- 2 Creational Patterns
- Factory Pattern
- What Is a Factory Pattern?
- Problem 1: Implementation classes with a common base are created in multiple places and no uniformity exists between creational logic
- Solution 1: Use a factory to encapsulate the class creation code in one place
- Problem 2: Class types to be created are determined by immutable logical code and extending the returnable types requires scale modifications to the factory
- Solution 2a: Replace conditional logic with a class activator, using reflection to determine the needed types for different workflows
- Solution 2b: Use abstractions of the factory to determine allowable class types using inheritance (instead of reflection)
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Abstract Factory Pattern
- What Is an Abstract Factory Pattern?
- Problem 1: Different class types need a common interface to a factory method for creation of internal attributes
- Solution 1: Allow an abstract factory to act as a common base interface for the factories between classes
- Problem 2: We need to make a builder more extendible to allow different functional processes to occur without changing the builder
- Solution 2: Use an abstract factory to define common creational methods for the builder
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Builder Pattern
- What Is a Builder Pattern?
- Problem 1: A class needs several operations to create and initialize each of its attributes in an expected order of operations, and each class type instance needs different attribute values
- Solution 1: Use a combination of a director and a builder to encapsulate and uniformly define the processes in the expected order, and use inherited members of the builder to change each type’s reacti
- Problem 2: A factory produces classes that need initialization, configuration, data, or state set during creation and this can differ between class types and spans multiple operations
- Solution 2: Use registered builders for each class type inside your factory to aid in the initialization of class types
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Prototype Pattern
- What Is a Prototype Pattern?
- Problem: A class that cannot be constructed outside its assembly or package needs a copy made that keeps its current state intact
- Solution: Create a prototype method on the class to return a cloned instance with its state copied to the needed depth
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Singleton Pattern
- What Is a Singleton Pattern?
- Problem: A global class in the application needs to hide its constructor and maintain only one instance of itself while allowing all of its methods to be accessed as instance methods
- Solution: Use the Singleton pattern to hide the constructor and maintain an instance of the class inside itself
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Factory Pattern
- 3 Behavioral Patterns
- Chain of Responsibility Pattern
- What Is a Chain of Responsibility Pattern?
- Problem: A group of classes each have processes to run in turn, but there is no way to directly determine in which class order each should run its process
- Solution: Use a chained association of classes that have interdependence on each other to define the order of operations
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Command Pattern
- What Is a Command Pattern?
- Problem: A document object needs a way to add and store undo and redo actions
- Solution: Use a command as the request to store the text and allow the command to handle undo and redo requests of the document
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Interpreter Pattern
- What Is an Interpreter Pattern?
- Problem 1: The format of a date needs to be different depending on the particular type of date expression needed
- Solution 1: Use an interpreter and expression engine to manage the different date formats by expression type
- Problem 2: We need to create classes from metadata from remote packages or assemblies and load them using a common interpreter
- Solution 2: Allow an interpreter to create the classes from metadata using reflection to recurse into the remote assemblies or packages
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Iterator Pattern
- What Is an Iterator Pattern?
- Problem: A list object needs a way to move through each element in the list in consecutive order, retaining the position of the current record
- Solution: Create a list iterator that keeps the current record position and has methods to read and move to the next record or to any record in the list
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Mediator Pattern
- What Is a Mediator Pattern?
- Problem: Message windows reference each other directly, and if new windows are added the code cannot easily manage each window’s reference to the other
- Solution: Use a mediator to control messages between each window
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Memento Pattern
- Observer Pattern
- What Is an Observer Pattern?
- Problem: We have several child forms of an MDI form that we need to inform of changes that occur in the MDI form, and we have no way to do this automatically
- Solution: Use the Observer pattern to provide notifications to the child forms when the MDI form state is changed
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- State Pattern
- What Is a State Pattern?
- Problem 1: We have no way to determine the state of an object without performing calculations outside an object
- Solution 1: Use a state object that can change itself as the context object changes to determine the context state
- Problem 2: We need to prevent unsynchronized or dirty updates between factory class instantiation calls
- Solution 2: Make the factory a static interface, and maintain class states across multiple threads
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Strategy Pattern
- What Is a Strategy Pattern?
- Problem: We have a series of algorithmic classes that have no correlation and are not easily exchanged but are needed to do so
- Solution: Make each class inherit from a common base to provide ease of scalability and exchange between class types so one algorithm class can easily be exchanged for another
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Template Pattern
- Visitor Pattern
- What Is a Visitor Pattern?
- Problem: We have a need for a class that encapsulates database transactions and performs specific functions based on the class instance type
- Solution: Place each database transaction type in a class that controls that functionality, and use this class to send the data into the database
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Chain of Responsibility Pattern
- 4 Structural Patterns
- Adapter Pattern
- What Is an Adapter Pattern?
- Problem: We wish to allow one class to use another’s methods without using direct inheritance
- Solution: Allow an adapter class to hold an instance of the desired class and adapt its methods, properties, and events through the adapter’s methods, properties, and events
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Bridge Pattern
- What Is a Bridge Pattern?
- Problem: We need to allow a class to use functionality from a series of class types without using direct inheritance
- Solution: Create a series of classes and allow a bridge class to hold the desired instance of the series and adapt its methods, properties, and events through the bridge’s methods, properties, and eve
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Composite Pattern
- What Is a Composite Pattern?
- Problem: A way is needed to allow a group of classes with a common method and different functionality to work together in sequence without compiling the sequence beforehand
- Solution: Group each class into a composite, which will manage when each class will have its common method called and will allow manipulation of the sequence of calls
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Decorator Pattern
- What Is a Decorator Pattern?
- Problem: We wish to have certain functions associated with a class type only when desired, but not all the time
- Solution: We allow a decorator that inherits from the class we are using to take its place and act as the class, but with the increased functionality of the decorator
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Facade Pattern
- What Is a Facade Pattern?
- Problem: We have several classes whose methods make up a process, but we need to control the order in which these classes are called by code outside the assembly
- Solution: Create a facade layer with interfaces to desired classes that are called in the proper order and allow the subsystem classes to only be called inside the facade assembly
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Flyweight Pattern
- What Is a Flyweight Pattern?
- Problem: A text document uses individual object instances for each character and quickly becomes unwieldy
- Solution: Use shared flyweight objects to instantiate a limited number of character objects that use their current context to change the extrinsic state
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Proxy Pattern
- What Is a Proxy Pattern?
- Problem: You have an object in a different domain or server address you would like to access in the current domain, but do not want to allow construction of the object in the local domain
- Solution: Use a proxy to bridge the two separate domains and allow access between programs
- Comparison to Similar Patterns
- What We Have Learned
- Related Patterns
- Adapter Pattern
- Glossary of Terms
- Index
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.