Dip is a simple Swift Dependency container. Use protocols to resolve your dependencies and avoid singletons / sharedInstances!
Features:
- Scopes. Dip supports 5 different scopes (or life cycle strategies): Unique, Shared, Singleton, EagerSingleton, WeakSingleton;
- Auto-wiring & Auto-injection. Dip can infer your components’ dependencies injected in constructor and automatically resolve them as well as dependencies injected with properties.
- Resolving optionals. Dip is able to resolve constructor or property dependencies defined as optionals.
- Type forwarding. You can register the same factory to resolve different types implemeted by a single class.
- Circular dependencies. Dip will be able to resolve circular dependencies if you will follow some simple rules;
- Storyboards integration. You can easily use Dip along with storyboards and Xibs without ever referencing container in your view controller’s code;
- Named definitions. You can register different factories for the same protocol or type by registering them with tags;
- Runtime arguments. You can register factories that accept up to 6 runtime arguments (and extend it if you need);
- Easy configuration & Code generation. No complex containers hierarchy, no unneeded functionality. Tired of writing all registrations by hand? There is a cool code generator that will create them for you. The only thing you need is to annotate your code with some comments.
- Weakly typed components. Dip can resolve “weak” types when they are unknown at compile time.
- Thread safety. Registering and resolving components is thread safe;
- Helpful error messages and configuration validation. You can validate your container configuration. If something can not be resolved at runtime Dip throws an error that completely describes the issue;
