Upload
chris-eargle
View
1.922
Download
0
Tags:
Embed Size (px)
DESCRIPTION
Design and Implementation patterns have changed in object-oriented languages such as C# with the introduction of new language features, advances in object-oriented design, and the inclusion of functional language aspects. This session will explore the impact this has on design and implementation patterns and how they can be leveraged to build more elegant systems.
Citation preview
The Evolution of PatternsInfluences and Examples of Emerging Patterns
Chris Eargle
Chris EargleTelerik Developer Evangelist
INETA Director
Microsoft MVP – Visual C#
MCPD, MCTS, etc
kodefuguru.com
What is a Pattern?An element of reusable software
Names, motivates, and explains a general design that addresses recurring design problems
Describes the problem, the solution, when to apply the solution, and its consequences
304/11/2023
Implementation LevelsInvisible Part of the language
Informal Referred to by name, but must be re-implemented for each use
Formal Implement pattern itself within the language
InfluencesLanguage Features
Innovations in Object-Oriented Design
Other Programming Paradigms
LanguageDesign patterns may be a sign of missing language features
“16 of 23 patterns have qualitatively simpler implementation in Lisp or
Dylan than in C++ for at least some uses of each pattern.”
Peter Norvig
Language FeaturesKeywords are added to languages
Typically streamlines a process
May be tied to other paradigms
InnovationsObject-Oriented Programming is mature
Sometimes an idea takes hold…
challenges OO Principles…
and takes the community by storm.
Fluent InterfacesUtilizes method chaining
Defined through the return value of a called method
Self referential - the new context is equivalent to the last context
Fluent InterfacesEnglish-readable, left-to-right code
May violate command-query separation with stateful objects
Terminated through the return of a void context
ParadigmsThere is a huge ecosystem of programming languages
Most languages fall into categories other than OO
These slowly make their way into modern OO languages
GenericAlgorithms use types to be specified later
Reduces duplication
Pioneered by ADA in 1983
May be harder to understand
TerminologyGenerics
Ada, Eiffel, Java, C#, F#, and Visual Basic .NET
Parametric Polymorphism
ML, Scala and Haskell
Templates
C++
FunctionalTreats computation as the evaluation of functions
Avoids state and mutable data
Roots in lambda calculus
Terminologyfirst class functions
functions can be passed as arguments
higher-order functions
take one or more functions as input
or outputs a function
combinators
takes one or more functions as input
and outputs a function
“a combinator is a function which builds program fragments from
program fragments…”
John Hughes
Terminologypure functions
no side effects, which means the function called with the same arguments returns the same result
anonymous functions
a function defined, and possibly called, without being bound to an identifier.
continuation-passing style
when a function is complete, the computation is passed to a continuation function
Singleton
Singleton PatternRestricts class instantiation to one instance
Useful when only one instance is needed in system
Some consider this an anti-pattern
Not the same as a static class
2004/11/2023
Singleton Diagram
- Singleton()S+ Instance
Singleton<<singleton>>
Retrieves a single, maintained instance of class.
Influence on LanguageA few modern languages directly implement this construct
Scala Example
// Singleton uses the object keyword instead of classobject Utilities { val test = "Test App" def loadImages() = { // ... } def createManager():EntityManager = { // ... }}
Lazy Initialization
Lazy InitializationDelays creation of an object
Use when eager initialization is resource intensive
Often used with a factory method (more later)
Iterator
Iterator Patterniterator an object that provides a standard way to
examine all element of any collection.
Has a uniform interface for traversing many data structure without exposing their implementations.
Supports concurrent iteration and element removal.
No need to know the internal structure of collection.
Iterator Diagram
+ CreateIterator()
Aggregate<<interface>>
+ First()+ Next()+ IsDone()+ CurrentItem
Iterator<<interface>>
+ CreateIterator()
ConcreteAggregate ConcreteIterator
Client
Command
Command Patternused to represent and encapsulate all the information needed to call a method at a later time
Terminologyclient
instantiates the command object and provides the information required to call the method at a later time.
invoker
decides when the method should be called
receiver
instance of the class that contains the method's code
Command DiagramInvoker
+ Execute()
Command<<interface>>
+ Action()
Receiver
+ Execute()
ConcreteCommand
Invoker
Fluent CommandThe Execute method return the object
Enables quick access to return properties
3304/11/2023
command.Execute(); var results = command.Results;
var results = command.Execute()
.Results;
Delegate CommandExecute is accepted as a function
Factory
Factory MethodMethod used to create an object
Used when it is more complex to simply instantiate
Don’t confuse this with abstract factory, a generalized pattern for building a series of factories
Useful in C# to take advantage of generic inference
Function FactoryCombinators correspond to factory methods for functions
Factory FunctionUtilizes a function to create an object
Strategy
Strategy PatternDefines family of algorithms
Encapsulates algorithms to make them interchangeable
Strategy Diagram
ContextInterface()
Context
AlgorithmInterface()
Strategy<<interface>>
AlgorithmInterface()
ConcreteStrategyB<<implementation>>
AlgorithmInterface()
ConcreteStrategyA<<implementation>>
<<implements>> <<implements>>
Containment
Use
Function StrategyWhen a strategy is required, allow owner to pass in a function
Prevents class explosion
Enables flexibility
4204/11/2023
Function Strategy
ContextInterface()
ContextStrategy
<<delegate>>Containment
Use
Template Method
Template PatternDefines the program skeleton of an algorithm
Encapsulate what changes and make it abstract
Subclasses implement those steps in the algorithm
Template Diagram
A+ PrimitiveOperation1()A+ PrimitiveOperation2 ()+ TemplateMethod()
AbstractClass
+ PrimitiveOperation1()+ PrimitiveOperation2()
ConcreteClass
Function TemplateEncapsulate what changes into functions
Allow owner to specify those pieces of the algorithm
Prevents class explosion
4704/11/2023
ReferencesOnline references and source code can be found at bitly.com/wHIBI0
ReferencesPatterns of Enterprise Application Architecture
-Martin Fowler
Revenge of the Nerds
-Paul Graham
Object World, May 5 1996
-Peter Norvig
Functional thinking: Functional design patterns, Part 1
-Neal Ford
Generalising Monads to Arrows
-John Hughes
Design Patterns: Elements of Reusable Object-Oriented Software
-GoF