Comparing to Zenject

Zenject is awesome. However, VContainer has the following advantages:

• Good performance.
• Most parts of reflections and assertions are isolated to the Container's build stage.
• Easy to read implementation.
• VContainer has carefully selected features and does not register data-oriented objects in the container or actively inject the View component. This prevents the DI declaration from becoming overly complex.
  • Zenject is often used to inject into dynamic or datacentric objects, but this is complicated
  • In VContainer, injection of MonoBehaviour is recommended over injection into MonoBehaviour.
  • Zenject looks up all GameObjects in reflection when the scene starts, but this operation is expensive; VContainer does not do this.

Code size (v1.3.0)

API difference

Basic

Zenject	VContainer
Container.Bind<Service>() .AsTransient()	builder.Register<Service>(Lifetime.Transient)
Container.Bind<Service>() .AsCached()	builder.Register<Service>(Lifetime.Scoped)
Container.Bind<Service>() .AsSingle()	builder.Register<Service>(Lifetime.Singleton)
Container.Bind<IService>() .To<Service> .AsCached()	builder.Register<IService,Service>(Lifetime.Scoped)
Container.Bind( typeof(IInitializable), typeof(IDisposable)) .To<Service>() .AsCached()	builder.Register<Service>(Lifetime.Scoped) .As<IInitializable,IDisposable>()
Container.BindInterfacesTo<Service>() .AsCached()	builder.Register<Service>(Lifetime.Scoped) .AsImplementedInterfaces()
Container.BindInterfacesAndSelfTo<Foo>() .AsCached()	builder.Register<Service>(Lifetime.Scoped) .AsImplementedInterfaces() .AsSelf()
Container.BindInstance(obj)	builder.RegisterInstance(obj)
Container.Bind<IService>() .FromInstance(obj)	builder.RegisterInstance<IService>(obj)
Container.Bind( typeof(IService1), typeof(IService2)) .FromInstance(obj)	builder.RegisterInstance(obj) .As<IService1,IService2>()
Container.Bind( typeof(IService1), typeof(IService2)) .FromInstance(obj)	builder.RegisterInstance(obj) .As<IService1,IService2>()
Container.BindInterfacesTo<Service>() .FromInstance(obj)	builder.RegisterInstance(obj) .AsImplementedInterfaces()
Container.BindInterfacesAndSelfTo<Service>() .FromInstance(obj)	builder.RegisterInstance(obj) .AsImplementedInterfaces() .AsSelf()

Component

Zenject	VContainer
Container.Bind<Foo>() .FromComponentInHierarchy() .AsCached();	builder.RegisterComponentInHierarchy<Foo>()
Container.Bind<Foo>() .FromComponentInNewPrefab(prefab) .AsCached()	builder.RegisterComponentInNewPrefab(prefab, Lifetime.Scoped)
Container.Bind<Foo>() .FromNewComponentOnNewGameObject() .AsCached() .WithGameObjectName("Foo1")	builder.RegisterComponentOnNewGameObject<Foo>( Lifetime.Scoped, "Foo1")
.UnderTransform(parentTransform)	.UnderTransform(parentTransform)
.UnderTransform(() => parentTransform)	.UnderTransform(() => parentTransform)

Factory

Factory with parameter

Zenject

public class Enemy{    readonly float speed;
    public Enemy(float speed)    {        this.speed = speed;    }
    public class Factory : PlaceholderFactory<float, Enemy>;    {    }}
Container.BindFactory<float, Enemy, Enemy.Factory>();

VContainer

public class Enemy{    readonly float speed;
    public Enemy(float speed)    {        this.speed = speed;    }}
builder.RegisterFactory<float, Enemy>(speed => new Enemy(speed));

Factory with parameter & resolve dependency at runtime

Zenject

public class Enemy{    readonly Player player;    readonly float speed;
    public Enemy(float speed, Player player)    {        this.player = player;        this.speed = speed;    }
    public class Factory : PlaceholderFactory<float, Enemy>;    {    }}
Container.BindFactory<float, Enemy, Enemy.Factory>();

VContainer

public class Enemy{    readonly Player player;    readonly float speed;
    public Enemy(float speed, Player player)    {        this.player = player;        this.speed = speed;    }}
builder.RegisterFactory<float, Enemy>(container =>{    var player = container.Resolve<Player>();    return speed => new Enemy(speed, player);}, Lifetime.Scoped);

Factory with prefab

Zenject

public class Enemy : MonoBehaviour{    Player player;
    [Inject]    public void Construct(Player player)    {        this.player = player;    }
    public class Factory : PlaceholderFactory<Enemy>    {    }}
Container.BindFactory<Enemy, Enemy.Factory>()    .FromComponentInNewPrefab(enemyPrefab);

VContainer

public class Enemy : MonoBehaviour{    Player player;
    public void Construct(Player player)    {        this.player = player;    }}
builder.RegisterFactory<Enemy>(container =>{    var player = container.Resolve<Player>();    return () =>    {        var enemy = Instantiate(enemyPrefab);        enemy.Construct(player);        return enemy;    };}, Lifetime.Scoped);

Misc

Zenject	VContainer
Signal	Not supported The central messaging pattern is useful, but depends largely on the style of the project, and the preferred implementation will vary. You can choose any implementation of UniRx.MessageBroker, UniTaskPubsub, Cysharp/MessagePipe or etc.
Memory Pool	Not supported Currently, any Memory pool implementation is not embed. Please inject the implementation according to the purpose of the project into Factory etc.
Container.Bind<Foo>() .FromComponentInNewPrefabResource("Some/Path/Foo")	Not Supported We should load Resources using LoadAsync family. You can use RegisterInstance() etc after loading the Resource.
Container.Bind<Foo>() .WithId("foo") .AsCached()	Not supported Duplicate type Resolve is not recommended. You can instead use type-specific Register builder.Register(Lifetime.Scoped).WithParameter("foo", foo)