Home articles iOS Design Patterns

Articles

[+] Articles

iOS Design Patterns

by Raviteja

What is Design Pattern

A design pattern is a recurring solution that solves a specific design problem
They are helpful for speeding up problem solving, ensuring that a developer doesn't have to reinvent the wheel for every situation
The design pattern is a common way to organize code so that it is reusable and more easily extensible

Design Patterns

Singleton
Delegate
Model View Controller
Observer
Facade
Command

1. Singleton

Singleton classes are very simple and useful design pattern in iOS

Ensure a single access point
Provides a global point
The class keeps track of its sole instance and ensures that no other instance can be created. Singleton classes are appropriate for situations where it makes sense for a single object to provide access to a global resource

Singleton - Code

//SingletonExample.h file

#import <Foundation/Foundation.h>

@interface SingletonExample : NSObject {
}

@property (nonatomic, retain) NSString *myText;

+ (id) sharedInstance;

@end

//SingletonExample.m file
#import "SingletonExample.h"

@implementation SingletonExample

@synthesize myText;

#pragma mark Singleton Methods
+ (id) sharedInstance {
static SingletonExample * sharedSingletonInstance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedSingletonInstance = [[self alloc] init];
});
return sharedSingletonInstance;
}

- (id)init {
if (self = [super init]) {
myText = [[NSString alloc] initWithString:@"Hello World" ];
}
return self;
}
@end

2. Delegate

Delegation as a clean and simple way of connecting objects and helping them to communicate with other.
Simply say delegate are Protocols, it sends message to Delegate object when event handled.

One example of this is UIScrollView

The UIScrollView class has no knowledge of what it should be scrolling as that is an application specific task. So to notify the application of scrolling events, UIScrollView uses the UIScrollViewDelegate
The application can implement the delegate and then intercept the scrolling events sent to it by the UIScrollView

Delegate -Code

UIScrollViewDelegate
- scrollViewDidScroll:
- scrollViewWillBeginDragging:
- scrollViewWillBeginDecelerating:
- scrollViewDidEndDecelerating:
- scrollViewDidZoom:

3. Model View Controller

All iOS apps use Model View Controllers (MVCs)
MVCs are the link between an app's data and its UI
The MVC is broken up as such:

Model - Underlying data
View - The view the user sees, the UI
Controller - Determines the interactions between the model and views

This keeps the program modularized, allowing for high cohesion and loose coupling

4. Observer

The observer pattern is used when one object wants to know when another object changes
This pattern is build into every NSObject vi Key-Value Observing
This is also often used with MVCs because when a model changes you often will want to update the views

The observer pattern is similar to the delegate pattern, however one key difference is that observable objects support multiple observers, while a delegate is just one object
However, with this expanded possibility comes one big pitfall: you must remember to remove an object as an observer when that object is deallocated, otherwise there will be a code leak
The following slide contains a code sample of what the Observable class looks like

Observer - Code

@interface Observable: NSObject

- (void)addObserver:(id<NSObject>)observer;
- (void)removeObserver:(id<NSObject>)observer;
- (void)notifyObservers:(NSInvocation*)invocation;