![](https://camo.githubusercontent.com/6b7cd5c7b7dbf9a931b5b884bb05c40ae8d753093f3e580f0f066778367cb5a8/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f756e6974792d323031392e332532306f722532306c617465722d677265656e) [![](https://camo.githubusercontent.com/2282d653dcad7244a2b0833377181231ef906c12fa403bffa5e96f25ea6520cd/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f6c6963656e73652f6e617470756e636865722f62696e646c6573736469)](https://github.com/natpuncher/bindlessdi/blob/master/LICENSE.md) bindlessdi === Lightweight dependency injection framework for Unity almost free of bindings designed to simplify and streamline the process of writing code. * [Installation](https://github.com/natpuncher/bindlessdi/raw/master/#installation) * [Usage](https://github.com/natpuncher/bindlessdi/raw/master/#usage) ## Installation * In **Package Manager** press `+`, select `Add package from git URL` and paste `https://github.com/natpuncher/bindlessdi.git` * Or find the `manifest.json` file in the `Packages` folder of your project and add the following line to dependencies section: ```json { "dependencies": { "com.npg.bindlessdi": "https://github.com/natpuncher/bindlessdi.git", }, } ``` ## Usage * [Initializing](https://github.com/natpuncher/bindlessdi/raw/master/#initializing-the-container) * [Injecting](https://github.com/natpuncher/bindlessdi/raw/master/#injecting) * [Bind Instance](https://github.com/natpuncher/bindlessdi/raw/master/#bind-instance) * [Instantiation Policy](https://github.com/natpuncher/bindlessdi/raw/master/#instantiation-policy) * [Factory](https://github.com/natpuncher/bindlessdi/raw/master/#factory) * [Unity Objects](https://github.com/natpuncher/bindlessdi/raw/master/#working-with-unity-objects) * [Unity Events](https://github.com/natpuncher/bindlessdi/raw/master/#unity-events) * [Optimizations](https://github.com/natpuncher/bindlessdi/raw/master/#optimizations) * [Tests](https://github.com/natpuncher/bindlessdi/raw/master/#tests) ### Initializing the Container To initialize **Bindlessdi** call `Container.Initialize()` from entry point of the game. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); var myGame = container.Resolve(); myGame.Play(); } } ``` ### Injecting **Bindlessdi** only supports **constructor injection**. ```c# public class MyGame { private readonly MyController _myController; public MyGame(MyController controller) { _myController = controller; } } ``` In most cases **Bindlessdi** will guess implementation by itself without any bindings. ```c# public class MyController : IController { } ``` ```c# public class MyGame { private readonly IController _controller; public MyGame(IController controller) { _controller = controller; } } ``` If there are several of implementations for specific interface, intended implementation should be defined by calling `container.BindImplementation()`. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); container.BindImplementation(); var myGame = container.Resolve(); myGame.Play(); } } ``` ```c# public class Foo : IFoo { } public class Bar : IBar { } public class Qux : IBar { } ``` ```c# public class MyGame { public MyGame(IFoo foo, IBar bar) { // bar is Qux } } ``` ### Bind Instance Already instanced objects could be added to container by calling `container.BindInstance(instance)`. Its also possible to add a bunch of them using `container.BindInstances(instances)`. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); var myController = new MyController(); container.BindInstance(myController); var guns = new IGun[] { new FireGun(), new ColdGun() }; container.BindInstances(guns); var myGame = container.Resolve(); myGame.Play(); } } ``` ```c# public class MyGame { public MyGame(MyController myController, FireGun fireGun, ColdGun coldGun) { } } ``` ### Instantiation Policy **Bindlessdi** resolves everything **as single instance** by default, but it can be changed. * By changing **default initialization policy** to `InstantiationPolicy.Transient`, so every resolve will create a new instance. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); container.DefaultInstantiationPolicy = InstantiationPolicy.Transient; var myGame = container.Resolve(); myGame.Play(); var myGame2 = container.Resolve(); myGame2.Play(); // myGame != myGame2 } } ``` * By **registering instantiation policy** for concrete type, so every resolve of this type will create a new instance. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); container.RegisterInstantiationPolicy(InstantiationPolicy.Transient); var myGame = container.Resolve(); var myGame2 = container.Resolve(); // myGame != myGame2 } } ``` * By **registering instantiation policy** for an interface or a base type, so every resolve of a type implementing it will get this policy override. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); container.DefaultInstantiationPolicy = InstantiationPolicy.Single; container.RegisterInstantiationPolicy(InstantiationPolicy.Transient); container.RegisterInstantiationPolicy(InstantiationPolicy.Single); var a1 = container.Resolve(); var a2 = container.Resolve(); // a1 == a2 var b1 = container.Resolve(); var b2 = container.Resolve(); // b1 != b2 } } ``` * By passing **instantiation policy** to `container.Resolve()` method, so only this call will create a new instance. ```c# public class EntryPoint : MonoBehaviour { private void Start() { var container = Container.Initialize(); var myGame = container.Resolve(); var myGame2 = container.Resolve(InstantiationPolicy.Transient); var myGame3 = container.Resolve(InstantiationPolicy.Transient); var myGame4 = container.Resolve(); // myGame != myGame2 != myGame3 // myGame == myGame4 } } ``` ### Factory To create instances on demand use **Factories** for a specific interface. Just add `IFactory` as a constructor argument and call `Resolve` with concrete type when needed. It is also possible to override instantiation policy on resolve. There is no need to bind **Factories**, they will be resolved automatically. ```c# public interface IBullet { } public class FireBullet : IBullet { } public class ColdBullet : IBullet { } ``` ```c# public class Gun { private readonly IFactory _factory; public Gun(IFactory factory) { _factory = factory; } public IBullet Fire() { return _factory.Resolve(InstantiationPolicy.Transient); } public IBullet Cold() { return _factory.Resolve(InstantiationPolicy.Transient); } } ``` ### Working with Unity Objects * Create an implementation of `SceneContext` class ```c# public class MyGameSceneContext : SceneContext { public override IEnumerable