Comparing to Zenject

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

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.

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 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)