How can I avoid several instances of the same model object in iOS (MVC)

Question

I am working on a project in which I have a model that is used by several different views and thereby viewcontrollers. These viewcontrollers have no knowledge of each others' existence, nor do they have any relationship to each other. This means that I have a model* in each of the viewcontrollers and when the views are loaded, I allocate the model in each class and make the pointers point at it. Or short: I allocate my model n times in n classes that use it, which I think is a waste of memory (not that I will run out of memory, but I think it's bad practice).

Is there a way in iOS where I (while still maintaining good MVC practice) am able to create and use the same instance of my model? Usually I have been programming in c++ where I would pass a reference to the model to the constructor of each class that should know the model. Example (c++):

// Let to classes know of the same model object
MyModel model;
ControllerA myControllerA(&model);
ControllerB myControllerB(&model);

Instead I do the following in each class that use my model (objective-c):

// ControllerA
model = [[MyModel alloc] init];

// Controller B
model = [[MyModel alloc] init];

I don't want to make all models singleton objects and in this specific project I think using an observer pattern would be an overkill.

So, my question is: How can i achieve this and is it even possible?

Answer 1

You can write your own initializer that takes a pointer to the Model.

in the .h file of your ControllerA and B

@property(nonatomic,assign)Model* myModel;

-(id)initWithModel:(Model*)model;

in the .m file of your ControllerA and B

@synthesize myModel;

-(id)initWithModel:(Model*)model{
    self = [super init];

    if(self){
        self.mymodel = model;

    }

    return self;
}

EDIT

If you are using the IB you would write your initilizer in the following way:

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil model:(Model*)model
{
    self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
    if (self) {

        self.mymodel = model;
    }
    return self;
}

Answer 2

I think, you need to use a singleton pattern

Trivial implementation of witch looks like this

YourClass.h

+ (id)sharedInstance;

YourClass.m:

+(id)singleton {
    static dispatch_once_t pred;
    static MyClass *shared = nil;


    dispatch_once(&pred, ^{
     shared = [[MyClass alloc] init];
    });
    return shared;
}

Good article about it apple reference

Answer 3

You've got the right idea: provide the model to the view controllers that need it when you create them; don't make go looking to a singleton or other global for the information they need.

Since you asked about view controllers, and since those are often instantiated from .xib or storyboard files, you may need to adjust your approach a little. Instead of providing a reference to the model in the initializer, you can simply add a property that stores a reference to the model to each of your view controllers. The object that's responsible for creating a view controller can then provide the model after the controller has been created. For example, your app delegate's -applicationDidFinishLaunchingWithOptions: method will be called after the root view controller is created, and that's a good time to set up the model and point the root view controller at it:

-applicationDidFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    // set up the model
    self.model = [[MyModel alloc] initWithFile:...];

    // get the root controller and give it a pointer to the model
    MyFirstViewController *firstController = self.window.rootViewController;
    firstController.model = model;
}

The root view controller can then pass the model on to other view controllers that it creates. If you have a tab based app, the app delegate might instead pass the model on to all the view controllers under the tab controller. In that case, your tab controller will be the window's root view controller, and you'd get to your view controllers like this:

NSArray *controllers = self.window.rootViewController.viewControllers;

The big advantage here over the singleton approach is that your view controllers don't assume anything about the rest of the app. They'll each use whatever model you give them. That makes your code cleaner, easier to manage, easier to rearrange, and so on.

Answer 4

Once you create your model objects, you can store these instances in a global dictionary with a key, in some class which you have only one instance of, i.e. a singleton. When a view controller needs this model, it can ask this singleton to give it the data it needs by providing a dictionary key.

Or you can store your data in coredata, and fetch it from there whenever you need it from a view controller. This way you'll also achieve persistence, if you need it.