O documento apresenta um resumo sobre padrões de projeto. Discute classificação de padrões, exemplos de Factory Method, Decorator, Observer e Strategy. Também aborda princípios SOLID e anti-padrões.

1. Design Patterns com C# Fernando Kakimoto [email_address] www.twitter.com/nandokakimoto

10. Classificação Propósito Criacional Estrutural Comportamental Escopo Classe Factory Method Adapter (class) Interpreter Template Method Objeto Abstract Factory Builder Prototype Singleton Adapter (object) Bridge Composite Decorator Facade Flyweight Proxy Chain of Responsability Command Iterator Mediator Memento Observer State Strategy Visitor

11. Factory Method Intenção Motivação Consequências Fornece uma interface para criação de famílias de objetos, sem especificar suas classes concretas A classe não pode antecipar o objeto que ela deve criar A classe precisa que a subclasse especifique o objeto criado Programação para interfaces Necessidade de subclasses Creator para criação de Products específicos

14. Factory Method

17. Factory Method class Program { static void Main( string [ ] args) { Figure figure = new LineFigure (); figure.DoSomething(); figure = new TextFigure (); figure.DoSomething(); } }

18. Decorator Intenção Motivação Consequências Adiciona responsabilidades dinamicamente a um objeto Adicionar responsabilidades a objetos ao invés de classes Responsabilidades podem ser retiradas Quando extensão por herança é impraticável Mais flexibilidade do que heranças estáticas Evita explosão de classes Inúmeros objetos semelhantes

21. Decorator

22. Decorator public abstract class LibraryItem { public int NumCopies { get; set; } public abstract void Display(); } public class Book : LibraryItem { private string Author; private string Title; public Book( string author , string title , int numCopies) { this. Author = author; this. Title = title; this. NumCopies = numCopies; } public override void Display() { Console. WriteLine( "*** Book ***" ); Console. WriteLine( "Author: {0}" , Author); Console. WriteLine( "Title: {0}" , Title); Console. WriteLine( "#Copies: {0}" , NumCopies); } }

23. Decorator public class Decorator : LibraryItem { protected LibraryItem LibraryItem { get; set; } public Decorator( LibraryItem libraryItem) { this. LibraryItem = libraryItem; } public override void Display() { LibraryItem.Display(); } } public abstract class LibraryItem { public int NumCopies { get; set; } public abstract void Display(); }

24. Decorator class Program { static void Main( string [ ] args) { Book book = new Book( &quot;Worley&quot;, &quot;Inside ASP.NET&quot; , 10); book.Display(); Borrowable borrowBook = new Borrowable (book); borrowBook.BorrowItem( &quot;Customer #1&quot; ); borrowBook.BorrowItem( &quot;Customer #2&quot; ); borrowBook.Display(); } } public class Borrowable : Decorator { public List < string > Borrowers { get ; private set ; } public Borrowable ( LibraryItem libraryItem ) : base (libraryItem) { this .Borrowers = new List < string >(); } public void BorrowItem( string name) { Borrowers.Add(name); this .LibraryItem.NumCopies- -; } public override void Display() { base. Display(); Borrowers.ForEach( b => Console.WriteLine ( &quot;borrower: {0}&quot; , b)); } }

25. Observer Intenção Motivação Consequências Define dependências entre objetos, tal que quando um objeto muda de estado, seus dependentes são notificados e atualizados Manter consistência entre objetos relacionados Manter baixo acoplamento Um objeto deve notificar outro objeto sem fazer suposições prévias Acoplamento abstrato entre Subject e Observer Suporte para comunicação broadcast Atualizações inesperadas

28. Observer

29. Observer public abstract class Subject <T> { private List < Observer <T>> Observers; public Subject() { this .Observers = new List < Observer <T>>(); } public void Attach( Observer <T> o) { this .Observers.Add(o); } public void Detach( Observer <T> o) { this .Observers.Remove(o); } public void Notify(T data) { this .Observers.ForEach(o => o.Update(data)); } } public class ClockTimer : Subject < DateTime > { public DateTime CurrentTime { get; set; } public ClockTimer( DateTime time) { this. CurrentTime = time; } public void Tick() { this. CurrentTime = DateTime .Now; this .Notify( this .CurrentTime); } }

30. Observer public interface Observer <T> { void Update(T data); } public class AnalogicTimer : Observer < DateTime > { public void Update( DateTime time) { Console .WriteLine( &quot;AnalogicTimer {0}&quot; , time); } } public class DigitalTimer : Observer < DateTime > { public void Update( DateTime time) { Console .WriteLine( &quot;DigitalTimer {0}&quot; , time); } }

31. Observer class Program { static void Main( string [ ] args) { ClockTimer timer = new ClockTimer ( DateTime .Now); AnalogicTimer analogicTimer = new AnalogicTimer (); timer.Attach(analogicTimer); DigitalTimer digitalTimer = new DigitalTimer (); timer.Attach(digitalTimer); timer.Tick(); timer.Detach(analogicTimer); Thread .Sleep(5000); timer.Tick(); } }

32. Strategy Intenção Motivação Consequências Define uma família de algoritmos, encapsula cada um, e os torna substituíveis. Configurar uma classe com um entre vários comportamentos Diferentes variação para um mesmo algoritmo Encapsula detalhes de implementação de um algoritmo Define um comportamento para contextos de reuso Alternativa a extensão de classes Elimina instruções condicionais

35. Strategy

36. Strategy public interface PersistenceStrategy <T> { void Save(T item); void Remove(T item); bool Exists(T item); } public class CollectionPersistence <T> : PersistenceStrategy <T> { public void Save(T item) { Console. WriteLine( &quot;CollectionPersistence: Save&quot; ); } public void Remove(T item) { Console .WriteLine( &quot;CollectionPersistence: Remove&quot; ); } public bool Exists(T item) { Console .WriteLine( &quot;CollectionPersistence: Exists&quot; ); return false; } }

37. Strategy class Program { static void Main( string [ ] args) { Contact c = new Contact() { Name = &quot;Fernando Kakimoto&quot;, PhoneNumer = &quot;(81)9162-2997&quot;, Email = &quot;nandokakimoto@gmail.com&quot; }; PersistenceStrategy < Contact > persistence = new CollectionPersistence < Contact >(); persistence.Save(c); persistence.Remove(c); persistence.Exists(c); persistence = new DataBasePersistence < Contact >(); persistence.Save(c); persistence.Remove(c); persistence.Exists(c); } } public class DataBasePersistence <T> : PersistenceStrategy <T> { public void Save(T item) { Console .WriteLine( &quot;DataBasePersistence: Save&quot; ); } public void Remove(T item) { Console .WriteLine( &quot;DataBasePersistence: Remove&quot; ); } public bool Exists(T item) { Console .WriteLine( &quot;DataBasePersistence: Exists&quot; ); return false; } }

48. Perguntas

49. Design Patterns com C# Fernando Kakimoto [email_address] www.twitter.com/nandokakimoto