Design Patterns in iOS

Design Pattern in iOS
What Design patterns can we see and use in iOS?
Observer
Delegate & DataSource
Notiﬁcation
KVC & KVO
Factory
class cluster
Singleton
All you don’t have to do, but you
should try to do. 
Using them for ﬂexible, loose-
coupling, reusable, readable

Observer
Observers register to notiﬁer and wait broadcast messages to do
something
Delegation & DataSource
[What] 
They are same design pattern, delegate to someone to process their jobs.
[Why] 
For MVC architecture, this pattern can deﬁne nice code architecture for
dispatch job clearly
[When] 
Some jobs are not belong some roles, they should to implement it 
Ex: View shouldn’t to process business logic or fetch data, it should
delegate to controller or model to do.

[How]
Tips:
1. Always delegate(or datasource) and caller
2. Delegate must conform caller’s protocol
3. If protocol is optional, caller must implement introspection
4. Delegate’s attribute always weak (memory leak)
Caller steps:
1. Deﬁne what jobs (method) need to delegate (protocol)
2. Deﬁne an instance variable to be dynamic type
3. If protocol has @optional, then caller must implement introspection
Delegate steps:
1. Adapt protocol
2. Be the caller’s delegate(assign self to caller’s delegate )
3. Implement protocol method

MyCaller.h
MyCaller.m

MyDelegate.m

delegate
caller
[self.delegate showMeTheMoney]
||
[MyDelegate showMeTheMoney]
MyDelegate0x00
0xFC
0x04
(weak)
MyCaller.m

At most of time, we don’t need to make wheel by
ourself
We use this pattern when we establish our library
or refactoring to follow MVC Architecture

Notiﬁcation
[What] 
When the observed object events happened, observers will be
notiﬁed
[Why] 
Loose-coupling between object and object, and keeping to
monitor events and react with it
[When] 
Some objects need to know some objects’s events are happened
or not 
Ex: network connection canceled and we want to interact with
it.

[How]
Tips:
1. Always have a default center to process notification
2. One notify - multi objects
3. Receiver can get any messages
4. Observed object posting notification whatever receiver exist or not
5. Delivering notifications to observer is synchronous
6. Using Notification Queues to deliver notifications asynchronously(FIFO)
establish notification steps:
1. Create a notification default center
2. Register observed/observer object to notification center
3. Using customize/default notification
4. Add method to the notification for waiting trigger

Synchronous notification
Register notification and send notification
implement the trigger method

remove notiﬁcation
Output log - It will wait notiﬁcation return

Asynchronous notiﬁcation(FIFO)

Default Notiﬁcation Name
https://developer.apple.com/library/ios/documentation/
UIKit/Reference/UIApplication_Class/index.html

We can see the notiﬁcation performed after
MainThread
We use this pattern when object needs to interact
with events, and it’s better than delegation when
there are multi objects need to communication.

KVC - KVO
[What] 
When the observed object changed, observers will be notiﬁed.
[Why] 
Loose-coupling between object and object, and keeping to
monitor values changed and react with it
[When] 
Object need to know some objects’s value changed or not 
Ex: An image loaded URL from data (sqlite, coredata, etc),
when data changed, image got notiﬁcation and do something 
KVC: Key Value Coding
KVO: Key Value Observe
https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/KeyValueCoding/Articles/Compliant.html#//
apple_ref/doc/uid/20002172-BAJEAIEE
http://rintarou.dyndns.org/2011/07/22/objective-c-programming-筆記-2/

KVC-compliance (See spec.)
Attribute and To-One Relationship Compliance
1. Attribute: Scalar type or C struct
2. To-One: Object
Indexed To-Many Relationship Compliance
1. NSArray
Unordered To-Many Relationship Compliance
1. NSSet
Accessor methods
1. Not only setter & getter, but also other access methods. Ex: Count, removal, etc
2. [receiver setValue: forKeyPath:], [receiver valueForKeyPath:]
KVO-compliance (See spec.)
KVC-compliant

[How]
Tips:
1. Instance variable or object need to fit KVC-compliant and KVO-compliant
2. If instance variable doesn’t declare by @property, need to implement
accessor method
3. Trigger mechanism always using accessor method
4. Sometimes need to override accessor method better than default
5. Sending notifications manually can decrease unnecessary notifications
establish KVC-KVO steps:
1. Declare objects or variables
2. Make them be KVC-compliant and KVO-compliant
3. Add observer and observed Objects
4. implement KVO protocol method

SecObject.h
common.h
Attribute - scalar type and C struct

ViewController.m

Implement this protocol method in your observer

If want to customize accessor methods, then follow
these implementation rules
Default Search Pattern for setValue:forKey:
-> 1. set<Key>:
-> 2. _<key>, _is<Key>, <key>, or is<Key> (if accessInstanceVariablesDirectly returns YES)
-> 3. invokes setValue:forUndefinedKey:
Default Search Pattern for valueForKey:
-> 1. get<Key>, <key>, or is<Key>
-> 2. countOf<Key> and (objectIn<Key>AtIndex:or <key>AtIndexes:) P.S.:(at least will call two methods
when call valueForKey:)
-> 3. countOf<Key>, enumeratorOf<Key>, and memberOf<Key>: (object will send to all methods)
-> 4. _<key>, _is<Key>, <key>, or is<Key> (if accessInstanceVariablesDirectly returns YES)
-> 5. invokes valueForUndefinedKey:
Accessor Search Patterns for Simple Attributes
https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/KeyValueCoding/Articles/
SearchImplementation.html

Default search pattern for mutableArrayValueForKey:
-> 1. insertObject:in<Key>AtIndex: and removeObjectFrom<Key>AtIndex:(corresponding
to the NSMutableArray primitive methods insertObject:atIndex: and removeObjectAtIndex:
respectively)
OR
insert<Key>:atIndexes: and remove<Key>AtIndexes: (corresponding to the
NSMutableArray insertObjects:atIndexes: and removeObjectsAtIndexes: methods).
-> 2. At least one insertion method and at least one removal method are found, messages
being sent to the original receiver of mutableArrayValueForKey:.
-> 3. set<Key>:
-> 4. _<key> or <key>(if accessInstanceVariablesDirectly returns YES)
-> 5. invokes setValue:forUndefinedKey:
Accessor Search Pattern for Ordered Collections

Something important to know
There are Accessor Search Pattern for Unordered Collections and
Accessor Search Pattern for Uniquing Ordered Collections rules,
they are similar to ordered collections.
For improving potential performance problem, ofﬁcial
recommend override step.1 method to fulﬁll what you want
If attribute is a non-object type, implement setNilValueForKey:
if need to pass Nil to attribute
Collection objects can’t contain nil as a value, instead you can use
NSNull. But dictionar yWithValuesForKeys and
setValuesForKeysWithDictionary will auto translate between
NSNull and nil.

Manual send changed notification
benefit: it can minimize triggering notifications or group a
number of changes into a single notification

Registering Dependent Keys
some values changed dependent on other values changed, it can
monitor these dependent values together.
For example: fullName is changed dependent on ﬁrstName and
lastName

Collection Operators - KVC-compliance
Simple Collection Operators
@avg, @count, @max, @min, @sum
Object Operators
1. distinctUnionOfObjects
2. unionOfObjects
3. distinctUnionOfArrays

Observer design pattern conclusion in iOS
There are three observer patterns - delegation, KVO, notification
Notification
1. If you want to monitor some events happened or not
2. If you want to broadcast notification to multi objects
KVO
1. If you want to monitor values change and do something
2. If you want to pass through controller to monitor data change -MVVM
delegate
1. You don’t always care object’s statement
2. If object have some jobs need someone to help

Class cluster (Factory)
[What] 
A mechanism for loose-coupling and good code architecture 
[Why] 
It can hide the detail of implementation, reusable and more
easier to implement similar but different classes
[When] 
There are many classes similar but different 
Ex: UIButton has many view’s types, but we just know
UIButtonType and put-in buttonWithType, it will create variety
of button.

[How]
Tips:
1. Objects are declared by same class
2. Each one has different implementation details
establish class cluster steps:
1. Design how many types will be implement
2. Move out their same implementation details to superclass
3. establish the method which follows types to create instance
4. Implement superclass or subclass

common.h
MyCaller.m

MyCallerIsNormalMan.h (inherit from MyCaller)
MyCallerIsNormalMan.m Used it!

Singleton
[What] 
A mechanism for hold one instance and share everywhere 
[Why] 
Hold instance statement and more easier to pass instance
statement
[When] 
You have to record instance statement in App life-cycle, and you
need to fetch it’s data at many places. 
For example: UIApplication have an singleton instance variable
to provide App’s status for developer to fetch App’s information.

[How]
Tips:
1. Instance should be really need to stay in all App life-cycle
2. Don’t forget to do lock mechanism (semaphore) to prevent multi-access at
the same time
establish notiﬁcation steps:
1. Establish a method and build a static instance in it
2. Return the instance to provide other instance to access it
3. Establish lock mechanism
P.S.:
Please using dispatch_once to
avoid duplicate instances and
other lock mechanism, here
just sample code.

Conclusion 
iOS provides some mechanisms which follow
design pattern to us for complete our task faster, we
should not only use them, but also learn how to
make new one. 
All we don’t have to do, but we should try to do.

Design Patterns in iOS

More Related Content

What's hot (20)

Similar to Design Patterns in iOS (20)

Recently uploaded (20)

Design Patterns in iOS