The document discusses several design patterns including Command, Abstract Factory, Class Cluster, Chain of Responsibility, Composite, Iterator, Memento. It provides examples of each pattern from Cocoa frameworks like NSInvocation for Command and NSEnumerator for Iterator. It explains when each pattern should be used such as Command for parameterizing objects by actions or supporting undo/redo.

1. Cocoa Design Patterns Pavel Kravchenko, Ciklum

2. What is a Design Pattern? A design pattern is: a template for a design that solves a general problem a tool of abstraction that is useful in architecture A vocabulary to use when explaining complex software

3. Design principles encapsulate the aspects of system structure program to an interface, not an implementation Minimize coupling

4. The Command encapsulate a request as an object and Separates message sender and reciever

5. The Command

6. The Command Use when you want to: parameterize objects by an action to perform (Commands are an object-oriented replacement for callbacks). specify and execute requests at different times (you can transfer a command object to a different process). support undo. support logging changes.

7. The Command Example: NSInvocation (encapsulates an Objective-C message) An invocation object contains a target object, method selector, and method arguments You can dynamically change its target and arguments you can also obtain the return value from the object you can repeatedly invoke a message with multiple variations in target and arguments

8. Abstract Factory Provide an interface for creating families of related or dependent objects without specifying their concrete classes. The client is decoupled from any of the specifics of the concrete object obtained from the factory.

9. Abstract Factory

10. Abstract Factory Use the Abstract Factory pattern when: • a system should be independent of how its products are created and represented. • a system should be configured with one of multiple families of products. • a family of related product objects is designed to be used together

11. Class cluster A class cluster is an architecture that groups a number of private, concrete subclasses under an abstract superclass. The abstract superclass declares methods for creating instances of its private subclasses. Each object returned may belong to a different private concrete subclass. you don’t, and can’t, choose the class of the instance.

12. Class cluster NSNumber *aChar = [NSNumber numberWithChar:’a’]; NSNumber *anInt = [NSNumber numberWithInt:1]; NSNumber *aFloat = [NSNumber numberWithFloat:1.0]; NSNumber *aDouble = [NSNumber numberWithDouble:1.0];

13. Class cluster Since numbers of different types can be converted from one type to another and can be represented as strings, for example, they could be represented by a single class. aChar , anInt , aFloat , aDouble —are objects of different private subclasses but them interfaces declared by the NSNumber Don't release objects returned from factory methods

14. Chain of Responsibility Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it. Each object either handles the request or passes it to the next object in the chain.

15. Chain of Responsibility

16. Chain of Responsibility Use Chain of Responsibility when more than one object may handle a request, and the handler isn't known apriori . The handler should be ascertained automatically. you want to issue a request to one of several objects without specifying the receiver explicitly. the set of objects that can handle a request should be specified dynamically.

17. Chain of Responsibility Chain consists of a series of responder objects (that is, objects inheriting from UIResponder ) If a given responder object doesn’t handle a particular message, it passes the message to the next responder in the chain An application can have as many responder chains as it has windows Only one responder chain can be active at a time—the one associated with the currently active window.

18. Chain of Responsibility If a view is managed by a UIViewController object, the view controller becomes the next responder in the chain. The design of the view hierarchy, which is closely related to the responder chain, adapts the Composite pattern. Action messages—messages originating from control objects—are based on the target-action mechanism, which is an instance of the Command pattern.

19. Composite Compose related objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

20. Composite

21. Composite Use the Composite pattern when you want to represent part-whole hierarchies of objects. you want clients to be able to ignore the difference between compositions of objects and individual objects. Clients will treat all objects in the composite structure uniformly.

22. Composite The views in a window are internally structured into a view hierarchy. At the root of the hierarchy is a window and its content view, a transparent view that fills the window’s content rectangle. Views that are added to the content view become subviews of it, and they become the superviews of any views added to them. A view can have one (and only one) superview and zero or more subviews.

23. Composite

24. Iterator Provide an interface to access the elements of an aggregate object sequentially without exposing its underlying representation. transfers the responsibility for accessing the elements from the collection to an iterator. Different iterators can carry out different traversal policies.

25. Iterator Use the Iterator pattern to access an aggregate object's contents without exposing its internal representation. to support multiple traversals of aggregate objects. to provide a uniform interface for traversing different aggregate structures.

26. Iterator

27. Iterator The NSEnumerator class in the Foundation framework implements the Iterator pattern. Instances of NSDirectoryEnumerator class recursively enumerate the contents of a directory in the file system. The collection classes such as NSArray , NSSet , and NSDictionary include methods that return an enumerator appropriate to the type of collection.

28. Memento The Memento pattern captures and externalizes an object’s internal state—without violating encapsulation—so that the object can be restored to this state later. The Memento pattern keeps the important state of a key object external from that object to maintain cohesion.

29. Memento

30. Memento Use the Memento pattern when a snapshot of (some portion of) an object's state must be saved so that it can be restored to that state later, and a direct interface to obtaining the state would expose implementation details and break the object's encapsulation.

31. Memento Archiving converts the objects in a program, along with those objects’ properties (attributes and relationships) into an archive that can be stored in the file system or transmitted between processes or across a network. The archive captures the object graph of a program as an architecture-independent stream of bytes that preserves the identity of the objects and the relationships among them. object’s type is stored along with its data. Encoding and decoding are operations that you perform using an NSCoder object, preferably using the keyed archiving technique (using NSKeyedArchiver classes). The object being encoded and decoded must conform to the NSCoding protocol