VContainer how to's

[SimonNordon4]

Hey guys, I thought it would be a good idea to open up a discussion for tips and tricks. The current documentation is extremely rich in its depth, but it would great to have a few more "Hello World" examples to help people get started.

I'll use language familiar to a Unity Developer and follow it with the DI explanation.

---

Spawn a GameObject prefab

Register a factory that returns an instance instantiated by the current scopes container

public class MyScope : LifeTimeScope
{
    // Define the prefab we want to spawn.
    [Serializedfield] public GameObject prefab;

    protected override void Configure(IContainerBuilder builder)
    {
        // Register the prefab factory
        builder.RegisterFactory<GameObject>(c => () => c.Instantiate(prefab), Lifetime.Scoped);

        // Note that under the hood, Register Factory is exactly the same of the line below.
        builder.Register<Func<GameObject>>(container => () => container.Instantiate(prefab), Lifetime.Scoped);
        
    }
}

Create a prefab spawner.

    public class PrefabSpawner : MonoBehaviour
    {
         // Inject the prefab factory.
        [Inject] private Func<GameObject> _factory;
        
        private void Start()
        {
            // Spawn the prefab
            var instance = _factory();
            instance.transform.position = Vector3.zero;
        }
    }

---

Spawn a GameObject prefab with parameters.

As an example, let's imagine you wanted to spawn a bullet, and set it's velocity when you created it.

public class FactoryScope : LifetimeScope
{
    [SerializeField] private GameObject prefab;

    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<Func<Vector3, GameObject>>(container => velocity =>
        {
            var instance = container.Instantiate(prefab);
            
            var bullet = instance.GetComponent<Bullet>();
            bullet.velocity = velocity;
            return instance;
            
        }, Lifetime.Scoped);
    }
}

There's a few issues with this code. We're assuming the prefab gameobject has a bullet component, which it may not. The other issue this is registering as 'Func<Vector3,GameObject> which means we can't create any new factories using this formatting. Instead we will instantiate the bullet directly.

---

Spawn a MonoBehaviour prefab with parameters.

public class FactoryScope : LifetimeScope
{
    // Note we now instantiate a Bullet monobehaviour, not a gameobject.
    [SerializeField] private Bullet prefab;

    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<Func<Vector3, Bullet>>(container => velocity =>
        {
            var bullet = container.Instantiate(prefab);
            bullet.velocity = velocity;
            return bullet;
            
        }, Lifetime.Scoped);
    }
}

we spawn the bullet like this

    public class BulletSpawner : MonoBehaviour
    {
        // Note how our factory registration is more specific.
        // Now we could also register a Func<Laser>, Func<Arrow> etc
        [Inject] private Func<Vector3,Bullet> _bulletFactory;
        
        private void Start()
        {
            var instance = _bulletFactory(transform.forward);
            instance.transform.position = transform.position;
        }
    }

---

Spawn a MonoBehaviour prefab using a Factory Class

If our prefab logic start's getting too large, it's not a good idea to define inside the Scope, but instead create a custom class to handle the logic for us.

public class BulletFactory
    {
        private IObjectResolver _resolver;
        private Bullet _prefab;
        
        // Generally you should never inject the resolver into a class, but factories are the exception.
        public BulletFactory(IObjectResolver resolver, Bullet prefab)
        {
            _resolver = resolver;
            _prefab = prefab;
        }

        public Bullet Create()
        {
            return _resolver.Instantiate(_prefab);
        }

        public Bullet Create(Vector3 velocity)
        {
            var bullet = _resolver.Instantiate(_prefab);
            bullet.velocity = velocity;
            return bullet;
        }

        // Make it as complex as you'd like.
        public Bullet Create(Vector3 velocity, float size, int damage, string nameOnBullet)
        {
            var bullet = _resolver.Instantiate(_prefab);
            bullet.velocity = velocity;
            bullet.size = size;
            bullet.damage = damage;
            bullet.gameObject.name = nameOnBullet;
            return bullet;
        } 
    }

Register our new BulletFactory class

public class FactoryScope : LifetimeScope
{
    [SerializeField] private Bullet prefab;

    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<BulletFactory>(Lifetime.Scoped).WithParameter(typeof(Bullet), prefab);
    }
}

and finally use it in our spawner.

    public class BulletSpawner : MonoBehaviour
    {
        [Inject] private BulletFactory _bulletFactory;
        
        private void Start()
        {
            var instance = _bulletFactory.Create(transform.forward, 1.0f, 10, "Bullet");
            instance.transform.position = transform.position;
        }
    }

Note that in all examples, the prefabs dependencies will be injected when instantiated.

If this was helpful to anyone I can show how to do Gameobject Pools as well.

---

Spawn a Prefab with it's own LifetimeScope

If you try to spawn a prefab that has it's own scope, you might notice you're getting null reference errors. We need to take a slightly different approach if our object has it's own LifetimeScope.

In this example, we'll look at spawning an enemy with it's own LifetimeScope.

public class GameScope : LifetimeScope
{
    [SerializedField] private Enemy enemyPrefab;
    protected override void Configure(IContainerBuilder builder)
    {
        //Spawn a child scope via a factory.
        builder.RegisterFactory<EnemyFacade>(() =>
        {
            var enemyScope = enemyPrefab.GetComponent<EnemyScope>();
            var childScope = CreateChildFromPrefab(enemyScope);
            return childScope.GetComponent<Enemy>();
         });
        }
}

In this example we had to use "CreateChildFromPrefab()" instead of the instantiate method.

---

Spawn a Prefab with it's own LifetimeScope and pass a parameter into the scope.

Maybe we want to the spawned prefab scope to automatically register an instance. For now the best solution seems to set a public field on your prefab scope before building it.

public class GameScope : LifetimeScope
{
    [SerializedField] private Enemy enemyPrefab;
    [SerializedField] private Transform enemyTarget;

    protected override void Configure(IContainerBuilder builder)
    {
        //Spawn a child scope via a factory.
        builder.RegisterFactory<EnemyFacade>(() =>
        {
            var enemyScope = enemyPrefab.GetComponent<EnemyScope>();
            enemyScope.EnemyTarget = enemyTarget;
            var childScope = CreateChildFromPrefab(enemyScope);
            return childScope.GetComponent<Enemy>();
         });
        }
}

The prefab scope would look something like this:

public class EnemyScope : LifetimeScope
{
    public Transform enemyTarget;

    protected override void Configure(IContainerBuilder builder)
    {
        if(enemyTarget==null)
            throw new NullReferenceException("Enemy Target can not be null in EnemyScope")
        builder.RegisterInstance(enemyTarget).As<ITarget>();
    }
}

I'm aware there's a way to register new services in children that are dynamically spawned, however I found in the context of prefabs this to be a little more straight forward.

It also allows use to set an EnemyTarget manually in the editor for testing purposes.

---

Createing a Gameobject Pool

        // TODO:

This one I haven't figured out yet

[SimonNordon4]

I did something silly and made my own ContainerBuilderExtension:

RegisterSystem is similar to RegisterEntryPoint, except register system is tied to the Scope's GameObject. That means if the gameobject with the scope on it is disabled, so are all of it's systems.

I also implemented IEnablable and IDisablable. This is so I can pool objects and actually disable Tick() without disposing.

I could have also totally done this manually, but I like make it syntactically similar.