What is SharedInstance actually?

Question

What is sharedInstance actually? I mean what is the usage?

Currently I'm having some problem in communicating between 2 different files.

Here's my question:

I have 1 file call A.h/A.m and another file call B.h/B.m. A.h need to access some of the data in B.h, so .... is there any possible way I could achieve what I want?

Just wonder is it "SharedInstance" able to solve my problem?

Answer 1

sharedInstance could be used for several ways.

For example you can access an object from a static context. Actually it is used most ways for supporting the Singleton-pattern. That means that just one object of the class is used in your whole program code, just one instance at all.

Interface can look like:

@interface ARViewController
{
}
@property (nonatomic, retain) NSString *ARName;

+ (ARViewController *) sharedInstance;

Implementation ARViewController:

@implementation ARViewController
static id _instance
@synthesize ARName;
...
- (id) init
{
    if (_instance == nil)
    {
        _instance = [[super allocWithZone:nil] init];
    }
    return _instance;
}

+ (ARViewController *) sharedInstance
{
    if (!_instance)
    {
        return [[ARViewController alloc] init];
    }
    return _instance;
}

And to access it, use the following in class CustomARFunction:

#import "ARViewController.h"

@implementation CustomARFunction.m

- (void) yourMethod
{
    [ARViewController sharedInstance].ARName = @"New Name";
}

Answer 2

Shared Instance is a process by which you can access the same instance or object of a class anywhere in the project. The main idea behind this is to return the same object each time a method is called so that the values/properties stored in the instance can be used anywhere in the application.

This can be done in 2 simple process as follows:-

1) Using a static variable initialised only once

@implementation SharedInstanceClass

static SharedInstanceClass *sharedInstance = nil;

+ (id)sharedInstanceMethod
{
    @synchronized(self) {
        if (sharedInstance == nil) {
            sharedInstance = [SharedInstanceClass new];
        }
    }
    return sharedInstance;
}

@end

2) Using GCD's :-

+ (id)sharedInstance{
    static dispatch_once_t onceToken;
    static SharedInstanceClass *sharedInstance = nil;
    dispatch_once(&onceToken, ^{
        sharedInstance = [SharedInstanceClass new];
    });
    return sharedInstance;
}

These have to be called as:-

SharedInstanceClass *instance = [SharedInstanceClass sharedInstance];

Thus everytime the same instance will be returned from the function and the values set to the properties will be retained and can be used anywhere in the application.

Regards,

Answer 3

A sharedInstance is often implemented with the singleton pattern. Like in [UIApplication sharedApplication] -> There is only one application which you access through this singleton.

The idea is to have one instance of a class which can be accessed by calling a class method, in objective-c commonly named sharedXXX.

To solve your problem you could actually implement a singleton of a model class and write and access date to and from one existing instance which can be accessed with a static method, let's call it sharedModel.

The next step to improve on your model and updating the views would be KVO: Key Value Observing. You add an observer in your viewController to 'watch' changes made to your model. If such a change occurs your viewController is informed and you can update the view then.

You can read more about KVO in Apple's documentation or over at mindsizzlers for a small and easy tutorial.

Answer 4

Interface

@interface CouponSynchronizer : NSObject

+ (CouponSynchronizer *) sharedSynchronizer;

@end

Implementation

@implementation CouponSynchronizer

static CouponSynchronizer *sharedSynchronizer = nil;

+ (CouponSynchronizer *)sharedSynchronizer
{
    @synchronized(self) {
        if (sharedSynchronizer == nil) {
            sharedSynchronizer = [[self alloc] init];
        }
    }
    return sharedSynchronizer;
}

@end