Petr Puš Software Architect Unicorn a.s. Microsoft C# MVP

Co jsou design patterns a proč je používat? GoF design patterns Popis vybraných GoF design patterns

Design patterns = Návrhové vzory „Vzory“ pro návrh softwarových řešení Ověřená řešení opakujících se netriviálních problémů Tvorba objektů Granularita objektů Odpovědnost objektů Rozšiřitelnost řešení … Inspirovány vzory z tradiční architektury

K dispozici několik desítek vzorů Často technologicky nezávislé.NET nebo Java nebo C++ nebo.. Konkrétní implementace se mohou v závislosti na technologii lišit Někdy více možností implementace vzoru Závisí na možnostech technologie Řešení často kombinuje více návrhových vzorů najednou

Není potřeba znovu „vymýšlet kolo“..i když to vývojáři rádi dělávají ;-) Kvalitněji a rychleji navržená řešení Standardní implementace řešení Lepší pochopitelnost kódu Moderní platformy jsou plné design patterns Jednodušší komunikace Každý vzor – jedinečný název Ale pozor – nic se nemá přehánět.. Snaha použít vzory naprosto všude vede k negativním dopadům

Návrhové vzory (Design patterns) Vzory aplikovatelné ve fázi návrhu řešení Architektonické vzory (Architectural patterns) Vzory pro architektonického konceptu aplikace Integrační vzory (Integration patterns) Vzory řešící integraci (propojení) systémů Vzory nasazení (Deployment patterns) Vzory pro způsoby nasazení aplikací …

GoF = Gang of Four Čtveřice autorů nejpoužívanějších design patterns pro OOP Gamma, Helm, Johnson, Vlissides Kniha „Design Patterns: Elements of Reusable Object-Oriented Software“ Rozdělení vzorů do skupin Definice vzorů Základem pro další návrhové vzory

Využívají pokročilých postupů OOP Použití rozhraní (interface) Dědičnost Polymorfizmus Skladba objektů Delegování

Tvořivé vzory (Creational patterns) Zaobírají se procesem objektové tvorby Strukturální vzory (Structural patterns) Zabývají se skladbou tříd či objektů Vzory chování (Behavioral patterns) Řeší vzájemnou interakci tříd či objektů a jejich závislosti

Název Skupina Účel Jiné názvy Motivace Struktura Použití Účastníci Spolupráce účastníků Důsledky použití Známá použití Implementace Příbuzné vzory

Účel : Zajišťuje, aby třída měla v systému pouze jednu instanci Skupina : Tvořivé vzory Použití : Je potřeba zajistit, aby třída měla jednu instanci, která je pro ostatní objekty snadno přístupná Třída může zajistit, že nebude možné vytvořit žádnou jinou instanci

Struktura :

Implementace v C# : Využití statické vlastnosti pro poskytnutí jedinečné instance Využití privátního konstruktoru pro zamezení tvorby jiných instancí

Implementace v C# - Nejjednodušší varianta : public class Singleton { private static Singleton instance; private Singleton() {} public static Singleton Instance { get { if (instance == null) { instance = new Singleton(); } return instance; } public class Singleton { private static Singleton instance; private Singleton() {} public static Singleton Instance { get { if (instance == null) { instance = new Singleton(); } return instance; }

Implementace v C# - Thread safe, lazy : public class Singleton { private static readonly object locker = new object(); private static Singleton instance; private Singleton() { } public static Singleton Instance { get { lock (locker) { if (instance == null) instance = new Singleton(); return instance; } public class Singleton { private static readonly object locker = new object(); private static Singleton instance; private Singleton() { } public static Singleton Instance { get { lock (locker) { if (instance == null) instance = new Singleton(); return instance; }

Implementace v C# - Thread safe II public class Singleton { private static readonly Singleton instance; static Singleton() { instance = new Singleton(); } private Singleton() { } public Singleton Instance { get { return instance; } public class Singleton { private static readonly Singleton instance; static Singleton() { instance = new Singleton(); } private Singleton() { } public Singleton Instance { get { return instance; }

Účel : Definuje mezi-objektovou závislost, kde při změně stavu jednoho objektu jsou ostatní zainteresované objekty upozorněny Skupina : Vzory chování Použití : Změna jednoho objektu znamená změnu jiných objektů Objekt má upozorňovat jiné objekty bez toho, aby na mě měl silnou vazbu

Struktura :

Spolupráce :

Implementace v C# (Standardní OOP verze) Pro pozorovatele je definováno společné rozhraní, které definuje reakční metodu(y) Jednotliví pozorovatelé implementují reakční metodu a provedou konkrétní reakce Subjekt si uchovává reference na všechny pozorovatele Při provedení pozorované akce vyvolá subjekt reakční metodu na všech pozorovatelích

Implementace v C# (Standardní OOP verze) Rozhraní a implementace pozorovatele public interface IObserver { void Update(); } public interface IObserver { void Update(); } public class ConcreteObserver : IObserver { public void Update() { //reaction to the event } public class ConcreteObserver : IObserver { public void Update() { //reaction to the event }

Implementace v C# (Standardní OOP verze) Bázová třída pro sledované subjekty public abstract class Subject { private IList observers = new List (); public void Subscribe(IObserver observer) { observers.Add(observer); } public void Unsubscribe(IObserver observer) { observers.Remove(observer); } public void Notify() { foreach (IObserver observer in observers) { observer.Update(); } public abstract class Subject { private IList observers = new List (); public void Subscribe(IObserver observer) { observers.Add(observer); } public void Unsubscribe(IObserver observer) { observers.Remove(observer); } public void Notify() { foreach (IObserver observer in observers) { observer.Update(); }

Implementace v C# (Standardní OOP verze) Konkrétní sledovaný subjekt Použití subjektu a registrace pozorovatelů public class ConcreteSubject : Subject { public void ConcreteMethod() { UpdateState(); //observers notification Notify(); }... } public class ConcreteSubject : Subject { public void ConcreteMethod() { UpdateState(); //observers notification Notify(); }... } ConcreteSubject subject = new ConcreteSubject(); subject.Subscribe(new ConcreteObserver(„X“)); subject.Subscribe(new ConcreteObserver(„Z“)); subject.ConcreteMethod(); ConcreteSubject subject = new ConcreteSubject(); subject.Subscribe(new ConcreteObserver(„X“)); subject.Subscribe(new ConcreteObserver(„Z“)); subject.ConcreteMethod();

Implementace v C# Podpora pro vzor Observer je v C# na úrovni jazyku – Events Konkrétní jazykové konstrukce pro implementaci Použití delegátů jako rozhraní reakčních metod (EventHandler) Pro případné dodatečné informace k události slouží typy odvozené od EventArgs

Implementace v C# (Events) public abstract class Subject { public event EventHandler StateChanged; protected void RaiseStateChanged() { if (StateChanged != null) { StateChanged(this, EventArgs.Empty); } public class ConcreteSubject : Subject { public void ConcreteMethod() { UpdateState(); //observers notification RaiseStateChanged(); } … } public abstract class Subject { public event EventHandler StateChanged; protected void RaiseStateChanged() { if (StateChanged != null) { StateChanged(this, EventArgs.Empty); } public class ConcreteSubject : Subject { public void ConcreteMethod() { UpdateState(); //observers notification RaiseStateChanged(); } … }

Implementace v C# (Events) ConcreteSubject subject = new ConcreteSubject(); ConcreteObserver observer = new ConcreteObserver(); subject.StateChanged += ObserverMethod; subject.StateChanged += observer.Update; subject.ConcreteMethod(); … static void ObserverMethod(object sender, EventArgs e) { //reaction } ConcreteSubject subject = new ConcreteSubject(); ConcreteObserver observer = new ConcreteObserver(); subject.StateChanged += ObserverMethod; subject.StateChanged += observer.Update; subject.ConcreteMethod(); … static void ObserverMethod(object sender, EventArgs e) { //reaction } public class ConcreteObserver { public void Update(object sender, EventArgs args) { //reaction } public class ConcreteObserver { public void Update(object sender, EventArgs args) { //reaction }

Známá použití v.NET Reakce na UI akce (ASP.NET, WinForms, WPF) Sledování změn souborů (FileSystemWatcher) Validace XML (ValidationEventHandler) …

Účel : Poskytuje zástupce za jiný objekt za účelem řízení přístupu k objektu Skupina : Strukturální vzory Použití : Je potřeba řídit přístup k jinému objektu Je potřeba obohatit operace cílového objektu

Struktura :

Spolupráce :

Použití : Remote proxy Přístup ke vzdálenému objektu (WS, Remoting,..) Protective proxy Kontrola přístupu k objektu, například na základě oprávnění Smart proxy Zajištění dodatečných operací před/po volání metody objektu Virtual proxy „Lazy“ tvorba zastupovaného objektu Cache proxy Cachování výsledků metod objektu

Implementace v C# : Proxy třída implementuje rozhraní zastupovaného objektu Do klientských referencí jsou namísto skutečných objektů obsazováni zástupci Vhodné objekty vytvářet pomocí továrny Klient „neví“ o použití proxy

Implementace v C# : public interface ISubject { int Method(string arg); } public interface ISubject { int Method(string arg); } public class RealSubject : ISubject { public int Method(string arg) { //implementation.. } } public class RealSubject : ISubject { public int Method(string arg) { //implementation.. } } public class CacheProxy : ISubject { private ISubject proxiedSubject; private IDictionary cache; public int Method(string arg) { if (cache.ContainsKey(arg)) { return cache[arg]; } else { int result = proxiedSubject.Method(arg); cache[arg] = result; return result; } public class CacheProxy : ISubject { private ISubject proxiedSubject; private IDictionary cache; public int Method(string arg) { if (cache.ContainsKey(arg)) { return cache[arg]; } else { int result = proxiedSubject.Method(arg); cache[arg] = result; return result; }

Známá použití v.NET Web services.NET Remoting WCF Enterprise Library Validation Block

Dynamická tvorba proxy tříd za běhu Proxy třída vytvořena na základě typu zastupované třídy Vhodné když : Je mnoho tříd, které je potřeba zastoupit Je potřeba zastupovat klientem vytvořené třídy

Implementace dynamic proxy v.NET Služby.NET Remoting ContextBoundObject a ProxyAttribute Nelehká implementace Výhodou vyšší výkon Castle Dynamic Proxy Open-source projekt pro tvorbu dyn. proxies Typ ProxyGenerator – tvorba proxy Rozhraní IInterceptor – implementace proxy operací MS Enteprise Library MS Open-source projekt Typ ObjectBuilder – tvorba proxy

Implementace pomocí Caste DynamicProxy class LoggingInterceptor : IInterceptor { public object Intercept(IInvocation invocation, params object[] args) { //log before method.. return invocation.Proceed(args); //log after method.. } class LoggingInterceptor : IInterceptor { public object Intercept(IInvocation invocation, params object[] args) { //log before method.. return invocation.Proceed(args); //log after method.. } ISubject realSubject = new RealSubject(); ProxyGenerator generator = new ProxyGenerator(); ISubject proxy = (ISubject) generator.CreateProxy( typeof(ISubject), new LoggingInterceptor(), realSubject); int result = proxy.Method("Hello"); ISubject realSubject = new RealSubject(); ProxyGenerator generator = new ProxyGenerator(); ISubject proxy = (ISubject) generator.CreateProxy( typeof(ISubject), new LoggingInterceptor(), realSubject); int result = proxy.Method("Hello");

Účel : Umožňuje měnit algoritmus provedení úlohy bez ovlivnění klienta, který ji používá Skupina : Vzory chování Použití : Je potřeba různých variant algoritmu Variantu algoritmu je potřeba měnit za běhu Třída definuje mnoho druhů chování

Struktura:

Spolupráce:

Implementace v C#: Pro algoritmus je definováno společné rozhraní Jednotlivé implementace algoritmu implementují rozhraní algoritmu Jiný objekt pracuje pouze s referenční proměnnou typu rozhraní algoritmu Objektu je možné nastavit implementační typ algoritmu (parametr konstruktoru, set vlastnost)

Implementace v C#: public abstract class DataReader { public abstract object GetData(int id); } public abstract class DataReader { public abstract object GetData(int id); } public class XmlDataReader : DataReader { public override object GetData(int id) { //implementation of XML reading.. } public class XmlDataReader : DataReader { public override object GetData(int id) { //implementation of XML reading.. } public class DataBaseDataReader : DataReader { public override object GetData(int id) { //implementation of DB access.. } public class DataBaseDataReader : DataReader { public override object GetData(int id) { //implementation of DB access.. } public class DataFacade { public DataReader Reader { get; set; } public DataFacade(DataReader reader) { this.Reader = reader; } public object LoadData(int id) { return Reader.GetData(id); } public class DataFacade { public DataReader Reader { get; set; } public DataFacade(DataReader reader) { this.Reader = reader; } public object LoadData(int id) { return Reader.GetData(id); } public class Client { public static void UseDataFacade() { DataFacade facade = new DataFacade(new XmlDataReader()); object data = facade.LoadData(1); facade.Reader = new DataBaseDataReader(); data = facade.LoadData(1); } public class Client { public static void UseDataFacade() { DataFacade facade = new DataFacade(new XmlDataReader()); object data = facade.LoadData(1); facade.Reader = new DataBaseDataReader(); data = facade.LoadData(1); }

Známá použití v.NET: Provider pattern ADO.NET data providers Ukládání session state Membership Role management API … Ukládání ViewState (PageStatePersister)

Creational patterns Factory method Abstract factory Singleton Builder Structural patterns Adapter Decorator Facade Bridge FlyWeight Composite Proxy Behavioral patterns Interpret Template method Iterator Visitor Memento Observer Mediator Command Chain of responsibility State Strategy

Kniha „Design Patterns: Elements of Reusable Object-Oriented Software“ Ukázky implementace design patterns v C# Enteprise Solution Patterns Using Microsoft.NET us/library/ms aspx