Allow non-singleton services

[cburgdorf]

I understand that services in AngularJS are singletons. That's fine and often it is exactly what you want. But once you begin to build stateful services you might want to get a fresh instance per controller. How would you achieve this?

For example, let's say you build a twitter reader and you have built a twitterServices that holds state like the current username, the fetched stream data, the pagination position etc. Now let's say you want the UI to be tab based so that you get another stream view for another username that you own. You would also like to use the twitterService that you built but obviously you would like to use another instance.

My proposal would be to let people configure if a service should be injected as singleton or with a fresh instance.

I wrote a IOC library that does dependency injection pretty much the same way that Angular does it but lets you decide about the lifecycle of the instances: https://github.com/cburgdorf/swiftcore.js

I think Angular should adopt that.

Previous to the creation of this ticket I had a little discussion about that in the group that I just reference here: https://groups.google.com/forum/#!msg/angular/eeooXXaYFj0/C2FIWfse58cJ

[btford]

You can create new instances of controllers via the $controller service. Relevant documentation: http://docs.angularjs.org/api/ng.$controller

[cburgdorf]

But this is about non singleton services not controller...

[btford]

Can you come up with a use case that isn't controller?

The idea that all services are singletons does not stop you from writing singleton [factories](http://en.wikipedia.org/wiki/Factory_(software_concept\)) that can instantiate new objects. For instance:

myApp.factory('myService', function () {
  var MyThing = function () {};
  MyThing.prototype.foo = function () {};
  return {
    getInstance: function () {
      return new MyThing();
    }
  };
});

[mholtzhausen]

Awesome, thanx Brian. my workflow now looks like this for all services:

    myApp.factory('myServiceProvider',function(){
        var serviceProvider=function(){};
        serviceProvider.prototype.foo=function(){};

        var service = {
            getInstance:function(){ return new serviceProvider(); }
        }

        return service;
    });

    //Singleton Services
    myApp.factory('myService',['myServiceProvider',function(myServiceProvider){
        return myServiceProvider.getInstance();
    }]);

    //Where non-singletons are required
    function myController(myServiceProvider){
        var instance_a=myServiceProvider.getInstance();
        var instance_b=myServiceProvider.getInstance();
    };

    //Where singleton service is required
    function myOtherController(myService){
        myService.foo();
    };

[jrgleason]

I am confused what is the difference between using a service like this and just creating the prototype object and passing whatever DI needed in the instance constructor?

[gkalpak]

Less boilerplate 😃

Keep in mind that .service() and .value() are syntactic sugar over .factory(), which is turn is syntactic sugar over .provider(). Whatever you can do with service or value you can do with factory and whatever you can do with factory you can also do with provider. But based on your usecase, one of the methods will require you to write less boilerplate 😃