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.
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
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
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( "Worley", "Inside ASP.NET" , 10); book.Display(); Borrowable borrowBook = new Borrowable (book); borrowBook.BorrowItem( "Customer #1" ); borrowBook.BorrowItem( "Customer #2" ); 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 ( "borrower: {0}" , 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
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( "AnalogicTimer {0}" , time); } } public class DigitalTimer : Observer < DateTime > { public void Update( DateTime time) { Console .WriteLine( "DigitalTimer {0}" , 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
49. Design Patterns com C# Fernando Kakimoto [email_address] www.twitter.com/nandokakimoto
Hinweis der Redaktion
Escopo especifica se o padrão é aplicado ao objeto ou a classe. - classe: foca na relação de herança, fixos em tempo de compilação - objeto: foca na interação entre objetos, podendo ser mudados em tempo de execução Creational patterns abstract the object instantiation process: They hide how objects are created and help make the overall system independent of how its objects are created and composed. Structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities.