Transcript prezentace - Michal Jakubec

Použití návrhových vzorů v
prostředí jazyka C# .NET
Bc. Michal Jakubec
MCSE, MCSD, MCDBA, MCTS
http://www.jakubec.cz/
1
Agenda
•
•
•
•
•
17:00 až 17:10 – Představení WUGu
17:10 až 18:30 – Návrhové vzory GoF
18:30 až 18:45 – Přestávka a občerstvení
18:45 až 20:00 – Návrhové vzory v praxi
20:00 – Diskuse: postřehy z praxe
2
1. část
Návrhové vzory GoF
3
Co je návrhový vzor?
• Definice
„Obecně použitelné řešení
určitého problému v určitém kontextu“
• Specifikace
– Název vzoru
– Popis problému
– Popis řešení
– Důsledky použití vzoru, příp. alternativy
4
K čemu je to dobré?
•
•
•
•
•
Společný slovník vývojářů a architektů
Nemusíte "objevovat kolo"
Velice inspirativní pro další profesní rozvoj
Rozvíjí návrhové schopnosti
Usnadňují řešení návrhových a vývojových
problémů (většinou)
• Vedou k získání tvárnější implementace
funkčnosti (většinou)
5
Jak začít s návrhovými vzory?
• Pořiďte si knihu GoF a mějte ji po ruce
• Seznamte se s UML
• Připravte si tužku a papír
– později postačí propiska
• Diskutujte o vzorech a svých návrzích s kolegy
• Mějte odhodlání a pevnou vůli
– abstrakci se člověk učí celý život
6
Klasifikace vzorů GoF
Účel 
Přístup 
Tvorba instancí
(Creational)
Struktura
(Structural)
Chování
(Behavioral)
Třída
Factory Method
Adapter (C)
Interpreter
Template Method
Instance
Abstract Factory
Builder
Prototype
Singleton
Adapter (I)
Bridge
Composite
Decorator
Façade
Flyweight
Proxy
Chain of
Responsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor
7
Vzájemné vztahy vzorů GoF
8
Zadání ukázkové aplikace
• Vytvořte aplikaci, která umožní
– zadání jednoduchého algebraického výrazu s
konstantami a proměnnými v textové formě
– zadání hodnot jednotlivých proměnných ve výrazu
– vyhodnocení výrazu a zobrazení výsledku
9
Vzory GoF v praktické ukázce
•
•
•
•
Composite (Skladba)
Builder (Stavitel)
Interpreter (Interpret)
Command (Příkaz)
…možná naleznete nějaké další
10
Podoba uživatelského rozhraní
Kalkulátor algebraických výrazů
X
Výraz:
a - (b + c)
Proměnné:
a = 12, b = 3, c = 5
Výsledek:
4
Vypočítat
Smazat
Zavřít
http://www.infoq.com/presentations/Modeling-the-User-Interface
11
Gramatika platných výrazů
Zápis v Backusově-Naurově formě (BNF):
<expr> ::= <number> | <var> | <expr> <oper> <expr> |
"(" <expr> ")"
<oper> ::= '+' | '-' | '*' | '/'
<number> ::= <digit> | <digit> <number>
<digit> ::= "0" | "1" | "2" | … | "9"
<var> ::= <letter> | <letter> <var>
<letter> ::= "a" | "b" | "c" | ... | "z"
Možný výskyt bílých znaků (mezery, tabulátory, apod.) v definici
pro přehlednost neuvádím.
12
Příklady vyhovující gramatice
•
•
•
•
•
•
•
36
a+b
12 + c
5+a*9+b–c
5 + (a * 9) + b – c
(abc + xyz) / opq
(24 + (b * 3)) / (a – 2)
13
Zachycení hodnot proměnných
• Kolekce typu klíč-hodnota
Název proměnné (klíč kolekce)
Hodnota proměnné
a
26
b
38
…
…
14
Zachycení výrazu v paměti
(24 + (b * 3)) / (a – 2)
Binární strom
Kořen
/
+
24
Proměnná
-
*
b
Binární výraz
a
Konstanta
2
3
15
Vzor Composite (Skladba)
• skládáním jednoduchých objektů získáme
funkční celek
16
Zachycení výrazu – Composite
Left
Right
BinaryExpression
Symbol : string
«interface»
IExpression
VariableExpression
Name : string
ConstantExpression
Value : double
17
Praktická ukázka (1/5)
• Implementace zachycení výrazu
– rozhraní IExpression
– třída ConstantExpression
– třída VariableExpression
– třída BinaryExpression
• Doplnění překrytí metody ToString()
– umožní zobrazení textové podoby výrazu –
užitečné pro ladění
18
Vzor Builder (Stavitel)
• Odděluje konstrukci složeného objektu od
jeho reprezentace
19
Tvorba stromu výrazu – Builder
«interface»
IExpressionBuilder
ExpressionParser
ExpressionParser(builder : IExpressionBuilder)
Parse(text : string) : IExpression
PrefixExpressionBuilder
+12
builder BuildConstant(value : double)
BuildVariable(name : string)
BuildOperation(symbol : string)
BuildLeftBracket()
BuildRightBracket()
GetProduct() : IExpression
InfixExpressionBuilder
1+2
PostfixExpressionBuilder
12+
20
Praktická ukázka (2/5)
• Implementace tvorby stromu výrazu
– rozhraní IExpressionBuilder
– třída ExpressionParser
– třída InfixExpressionBuilder
21
Vzor Interpreter (Interpret)
• Definuje reprezentaci gramatiky a způsob
jejího vyhodnocení (interpretace)
22
Výpočet výrazu – Interpreter
«interface»
IExpression
Evaluate(context : IContext) : double
// pro ConstantExpression
return value;
// pro VariableExpression
return context.GetValue(name);
// pro BinaryExpression sčítání
return left.Evaluate(context)
+ right.Evaluate(context);
«interface»
IContext
GetValue(string name) : double
DictionaryContext
items : Dictionary<string, double>
Context(items : Dictionary<string, double>)
GetValue(name : string) : double
23
Praktická ukázka (3/5)
• Implementace výpočtu výrazu
– rozhraní IContext
– metoda IExpression.Evaluate(IContext)
– třída DictionaryContext
24
Tvorba kontextu – Builder
«interface»
IContextBuilder
ContextParser
ContextParser(builder : IContextBuilder)
Parse(text : string) : IContext
ArrayContextBuilder
builder BuildName(name : string)
BuildValue(value : double)
BuildAssignment()
BuildDelimiter()
GetProduct() : IContext
DictionaryContextBuilder
LinkedListContextBuilder
25
Praktická ukázka (4/5)
• Implementace tvorby kontextu
– rozhraní IContextBuilder
– třída ContextParser
– třída DictionaryContextBuilder
26
Vzor Command (Příkaz)
• Zapouzdří operaci tak, aby bylo možné ji
předávat a užívat různými subjekty
27
Napojení na UI - Command
MainForm
command
ButtonCalculate_Click()
ToolbarCalculate_Click()
command.Execute();
«interface»
ICommand
Execute()
CalculationCommand
CalculationCommand(
entryExpression : Control,
entryVariables : Control,
entryResult : Control)
Execute()
28
Praktická ukázka (5/5)
• Implementace napojení na UI
– rozhraní ICommand
– třída CalculationCommand
– deklarace atributu typu ICommand
– vytvoření instance CalculationCommand
29
Shrnutí
• Vzor Composite (Skladba)
– zachycení struktury algebraického výrazu
• Vzor Builder (Stavitel)
– tvorba stromu výrazu z jeho textové podoby
– tvorba kontextu z jeho textové podoby
• Vzor Interpreter (Interpret)
– výpočet hodnoty výrazu dle kontextu
• Vzor Command (Příkaz)
– napojení na UI
• … nějaké další vzory?
30
Trochu historie…
• Christopher Alexander:
A Pattern Language, 1977
• Kent Beck, Ward Cunningham: Using Pattern Languages
for Object-Oriented Programs, OOPSLA, 1987
• GoF: Design Patterns, OOPSLA, 1994
31
GoF: Gang of Four
Ralph Johnson, Erich Gamma,
Richard Helm, John Vlissides 
32
Rok 2005: 10. výročí vzorů GoF
Zdroj: http://laputan.org/
33
Občerstvení, názory, připomínky, otázky, odpovědi…
Přestávka
34
3. část
Návrhové vzory v praxi
35
Typické problémy ze života
•
•
•
•
Decorator vs. Proxy
Mediator vs. Observer
Visitor vs. Interpreter
Singleton v různých podobách
36
Decorator vs. Proxy
• Decorator
– skládá funkčnost
objektů
– zachovává rozhraní
• Proxy
– upravuje
funkčnost
objektu
– zachovává
rozhraní
37
Mediator vs. Observer
• Mediator
– fixní vztahy
(většinou)
• Observer
– variabilní
vztahy
(většinou)
Otázka: Najdete v těchto diagramech syntaktickou chybu?
38
Visitor vs. Interpreter
• Visitor
– visitor se při
průchodu mění
• Interpreter
– kontext se při
průchodu nemění
39
Singleton v různých podobách
• veřejný statický atribut
internal sealed class Singleton
{
public static readonly Singleton Instance = new Singleton();
private Singleton() { ... }
}
40
Singleton v různých podobách
• veřejná statická vlastnost
internal sealed class Singleton
{
private static readonly Singleton instance = new Singleton();
public static Singleton Instance
{
get
{
return instance;
}
}
private Singleton() { ... }
}
41
Singleton v různých podobách
• veřejná statická vlastnost jako proxy
internal sealed class Singleton
{
private static Singleton instance;
public static Singleton Instance
{
get
{
if (instance == null)
instance = new Singleton();
return instance;
}
}
private Singleton() { ... }
}
42
Singleton v různých podobách
• synchronizace vícevláknového přístupu (jde to lépe?)
internal sealed class Singleton
{
private static volatile Singleton instance;
public static Singleton Instance
{
get
{
lock(typeof(Singleton))
{
if (instance == null)
instance = new Singleton();
return instance;
}
}
}
private Singleton() { ... }
}
43
Singleton v různých podobách
• synchronizace vícevláknového přístupu (lepší varianta)
internal sealed class Singleton
{
private static object syncRoot = new object();
private static volatile Singleton instance;
public static Singleton Instance
{
get
{
lock(syncRoot)
{
if (instance == null)
instance = new Singleton();
return instance;
}
}
}
private Singleton() { ... }
}
44
Singleton v různých podobách
• double-checked locking optimization
internal sealed class Singleton
{
private static object syncRoot = new object();
private static volatile Singleton instance;
public static Singleton Instance
{
get
{
if (instance == null)
{
lock(syncRoot)
{
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
}
private Singleton() { ... }
}
45
O vzorech EAA
• hlavním autorem Martin Fowler
– http://www.martinfowler.com
• zejména architektonické a návrhové vzory
• vzory připraveny na základě bohatých
zkušeností autora z tvorby business aplikací
46
Přehled vzorů EAA
•
Domain Logic Patterns
–
•
Table Data Gateway (144), Row Data Gateway
(152), Active Record (160), Data Mapper
(165).
Unit of Work (184), Identity Map (195), Lazy
Load (200)
•
–
•
Identity Field (216), Foreign Key Mapping
(236), Association Table Mapping (248),
Dependent Mapping (262), Embedded Value
(268), Serialized LOB (272), Single Table
Inheritance (278), Class Table Inheritance
(285), Concrete Table Inheritance (293),
Inheritance Mappers (302).
Object-Relational Metadata Mapping
Patterns:
–
Metadata Mapping (306), Query Object (316),
Repository (322).
Optimistic Offline Lock (416), Pessimistic
Offline Lock (426), Coarse Grained Lock (438),
Implicit Lock (449).
Session State Patterns:
–
•
Remote Facade (388), Data Transfer Object
(401)
Offline Concurrency Patterns:
–
•
Model View Controller (330), Page Controller
(333), Front Controller (344), Template View
(350), Transform View (361), Two-Step View
(365), Application Controller (379).
Distribution Patterns:
Object-Relational Structural Patterns:
–
•
–
Transaction Script (110), Domain Model (116),
Table Module (125), Service Layer (133).
Object-Relational Behavioral Patterns:
–
•
Web Presentation Patterns:
Data Source Architectural Patterns
–
•
•
Client Session State (456), Server Session
State (458), Database Session State (462).
Base Patterns:
–
Gateway (466), Mapper (473), Layer
Supertype (475), Separated Interface (476),
Registry (480), Value Object (486), Money
(488), Special Case (496), Plugin (499), Service
Stub (504), Record Set (508)
Zdroj: http://martinfowler.com/eaaCatalog/
47
Praktická ukázka (1/2)
• Domain Model – třídy reprezentující prvky
výrazu a hodnoty proměnných
• Repository – hlavní přístupový bod k
mechanismu persistence výrazů a hodnot
proměnných
48
Princip Inversion of Control (IoC)
49
Dependency Injection
• Tři základní metody „kontejnerové“ injekce
– pomocí konstruktorů
– pomocí setterů
– pomocí „injekčních“ rozhraní
• Alternativa pomocí EAA vzoru Registry
– statické rozhraní – „pevné“ metody vrací produkt
– dynamické rozhraní – produkt získáván z kolekce
či pomocí reflexe
50
Praktická ukázka (2/2)
• Dependency Injection – výměna
implementace mechanismu persistence
• Adapter (GoF) – doplňková funkčnost k
mechanismu persistence výrazů
51
Zdroje
• http://sourcemaking.com/
• http://martinfowler.com/eaaCatalog/index.html
• http://martinfowler.com/articles/injection.html
52
Diskuse: názory, připomínky, otázky, odpovědi
Závěr:
53