Skip to content
Swinject extension to automatically register your services
Branch: master
Clone or download
Type Name Latest commit message Commit time
Failed to load latest commit information.
Sources Release 2.6.0 Mar 30, 2019
SwinjectAutoregistration.xcodeproj Remove Swift 5 specification from project file Mar 26, 2019
Tests Update to support Swift 5 Mar 26, 2019
bin Add public back to Container extension Mar 27, 2019
.Package.test.swift Update dependencies for package manager Sep 24, 2018
.gitignore Improvements for using the project with Carthage Apr 14, 2018
.swift-version Run test against Xcode 10 & swift 4.2 Sep 24, 2018
.travis.yml Try fix travis with cached builds Mar 30, 2019
Cartfile Update to support Swift 5 Mar 26, 2019
Cartfile.private Update to support Swift 5 Mar 26, 2019
Cartfile.resolved Update to support Swift 5 Mar 26, 2019
Gemfile Run test against Xcode 10 & swift 4.2 Sep 24, 2018
Gemfile.lock Fix Gemfile.lock Sep 24, 2018
Package.swift swift pm support Jan 18, 2017 Update Mar 30, 2019
SwinjectAutoregistration.podspec Release 2.6.0 Mar 30, 2019


Build Status Carthage compatible CocoaPods Version License Platform Swift Version

SwinjectAutoregistration is an extension of Swinject that allows to automatically register your services and greatly reduce the amount of boilerplate code.


  • iOS 8.0+ / Mac OS X 10.10+ / tvOS 9.0+
  • Xcode 8+


Swinject is available through Carthage or CocoaPods.


To install Swinject with Carthage, add the following line to your Cartfile.

github "Swinject/Swinject" "2.6.0"
github "Swinject/SwinjectAutoregistration" "2.6.0"

Then run carthage update --no-use-binaries command or just carthage update. For details of the installation and usage of Carthage, visit its project page.


To install Swinject with CocoaPods, add the following lines to your Podfile.

source ''
platform :ios, '8.0' # or platform :osx, '10.10' if your target is OS X.

pod 'Swinject', '2.6.0'
pod 'SwinjectAutoregistration', '2.6.0'

Then run pod install command. For details of the installation and usage of CocoaPods, visit its official website.


Here is a simple example to auto-register a pet owner

let container = Container()
container.register(Animal.self) { _ in Cat(name: "Mimi") } // Regular register method
container.autoregister(Person.self, initializer: PetOwner.init) // Autoregistration

where PetOwner looks like this:

class PetOwner: Person {
    let pet: Animal

    init(pet: Animal) { = pet

The autoregister function is given the PetOwner initializer init(pet:Animal). From its signature Swinject knows that it needs a dependency Animal and resolves it from the container. Nothing else is needed.

Autoregistration becomes especially useful when used to register services with many dependencies. Compare autoregistration code:

container.autoregister(MyService.self, initializer: MyService.init)

with equivalent code in pure Swinject:

container.register(MyService.self) { r in 
	MyService(dependencyA: r.resolve(DependencyA.self)!, dependencyB: r.resolve(DependencyB.self)!, dependencyC: r.resolve(DependencyC.self)!, dependencyD: r.resolve(DependencyD.self)!)

Another advantage is that if you add more dependencies during the development the registration code doesn't have to be rewritten.

Registration with name

Service can be also given name - same as with the regular register method.

container.autoregister(Person.self, name: "johnny", initializer: PetOwner.init)


You can also use auto-registration for services with dynamic arguments. Pet owner whose name needs to be passed as argument is defined like this:

class PetOwner: Person {
    let name: String
    let pet: Animal

    init(name: String, pet: Animal) { = name = pet

And registered like this

container.autoregister(Person.self, argument: String.self, initializer: PetOwner.init)

Swinject will register Person with the argument of type String. When container.resolve(Person.self, argument: "Michael") is called Swinject won't try to resolve String as dependency but instead pass "Michael" as the name.

To also pass pet as argument you can call

container.autoregister(Person.self, arguments: String.self, Animal.self, initializer: PetOwner.init)
container.autoregister(Person.self, arguments: Animal.self, String.self, initializer: PetOwner.init)

The order of the arguments listed is interchangeable. The auto-registration can't be used with more arguments and/or dependencies of the same type.

What kind of sorcery is this?

Wondering how does that work? Generics are heavily leveraged for the auto-registration. For registering service with two dependencies something similar to a following function is used:

public func autoregister<Service, A, B>(_ service: Service.Type, initializer: (A, B) -> Service) -> ServiceEntry<Service> {
   return self.register(service.self, factory: { r in 
       return initializer(r.resolve(A.self)!, r.resolve(B.self)!)
   } as (ResolverType) -> Service)

The initializer is a function like any other. By passing it as a parameter its dependencies can be inferred as (A, B) and automatically resolved. These functions are generated for up to 20 dependencies. Checkout the code for more info.


This extension also aims to reduce the amount of boilerplate while improving readability of the registration code. For that reason the operator ~> is introduced.

Petowner(pet: r~>)

// equivalent to

Petowner(pet: r.resolve(Animal.self)!)

The dependency is again inferred from the type in the initializer. To specify a concrete class you can use:

Petowner(pet: r ~> Cat.self)

To use a named service:

Petowner(pet: r ~> (Cat.self, name: "mimi"))

or to pass argument/s:

Petowner(pet: r ~> (Cat.self, argument: "Mimi"))
Petowner(pet: r ~> (Cat.self, arguments: ("Mimi",


When a service has multiple initializers, swift compiler can't be sure which should be used and you will get a ambigious use of init(x: y: z:). This can also happen if the service is extending another class that have initializer with the same number of arguments.

The solution is to specify the initializer like this:

container.autoregister(Person.self, initializer: PetOwner.init(name:pet:))

Auto-registration can't be used with named dependencies in their initializers. There is no way to get a name of dependency from the initializer. For example, following code can't be auto-registered:

container.register(Animal.self, name: "mimi") { _ in Cat(name: "Mimi") }
container.register(Animal.self, name: "charles") { _ in Cat(name: "Charles") }
container.register(Person.self) {
    PetOwner(pet: r.resolve(Animal.self, name: "mimi")


SwinjectAutoregistration generics is inspired by:


MIT license. See the LICENSE file for details.

You can’t perform that action at this time.