Is it possible to implement a Zenject-like GameObjectСontext using VContainer?

[finch-bird]

I have a SceneScopeLifetimeScope placed in the scene and a prefab containing DialogManagerLifetimeScope.
I'm trying to instantiate and register DialogManager in SceneScopeLifetimeScope and attach the local scope (which is already present in the prefab) to the container tree.

Here’s my latest attempt, but it doesn’t seem to work.
Any suggestions would be greatly appreciated. Thanks in advance!

 public class SceneScopeLifetimeScope : LifetimeScope
    {
        [SerializeField] private AssetReferenceComponent<DialogManager> _dialogManagerPrefab;
        public override void Install(IContainerBuilder builder)
        {
            GameObject asset = null;
            using (LifetimeScope.EnqueueParent(this))
            {
                asset = _dialogManagerPrefab.LoadAssetAsync().WaitForCompletion();
            }
            builder.Register<IDialogManager>(c => GameObject.Instantiate(asset).GetComponent<DialogManager>(), Lifetime.Scoped);
            builder.RegisterDisposeCallback(_ =>
            {
                Addressables.Release(asset);
            });
            
        }
    }

[finch-bird]

Ok, this kind of works, but it feels wrong. 😅 Are there any more elegant solutions?

        public override void Install(IContainerBuilder builder)
        {
            GameObject instance;
        
            using (LifetimeScope.EnqueueParent(this)) 
                instance = _dialogManagerPrefab.InstantiateAsync().WaitForCompletion();

            builder.Register<IDialogManager>(_ =>
            {
                instance.GetComponentInChildren<LifetimeScope>().Build();
                return instance.GetComponent<DialogManager>();
            }, Lifetime.Scoped);
                
            builder.RegisterBuildCallback(c =>
            {
                c.Resolve<IDialogManager>(); // prevent lazy initialization
                var objectScope = instance.GetComponentInChildren<LifetimeScope>();
                foreach (var child in instance.GetComponentsInChildren<Behaviour>().Where(x => x is not LifetimeScope))
                    objectScope.Container.Inject(child);
            });

            builder.RegisterDisposeCallback(_ =>
            {
                Addressables.ReleaseInstance(instance);
            });
        }

[tigran-sargsyan-w]

Yes — the Zenject GameObjectContext pattern maps to “a prefab that has its own LifetimeScope” in VContainer. You either (A) spawn that prefab as a child scope of your scene scope, or (B) if you must use Addressables, build the prefab’s LifetimeScope with the scene scope set as parent. No extra hacks needed.

1. Cleanest: create a child scope from a LifetimeScope prefab

Put a LifetimeScope on your prefab (next to DialogManager) and register its components inside that prefab scope.
Prefab DialogManagerScope.cs

using VContainer.Unity;

public class DialogManagerScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        // Registers the MonoBehaviours under this prefab so they get injected
        builder.RegisterComponentInHierarchy<DialogManager>();
        // register other components/services that belong to this prefab
        // builder.Register<SomeService>(Lifetime.Scoped);
    }
}

Scene scope spawns the prefab as a child

using VContainer.Unity;

public class SceneScopeLifetimeScope : LifetimeScope
{
    [SerializeField] private DialogManagerScope dialogManagerScopePrefab;

    protected override void Configure(IContainerBuilder builder)
    {
        // scene-level registrations...
    }

    protected override void Build()
    {
        base.Build();

        // Create a proper child scope; parenting & container links are handled
        CreateChildFromPrefab(dialogManagerScopePrefab);
    }
}

This gives you Zenject‐style composition: the prefab’s scope can resolve from the scene scope, while its own registrations stay isolated.

2. Addressables route (when you can’t drag a prefab reference)

If the prefab comes from Addressables, load → set the parent → Build() the child scope → (optionally) inject the hierarchy.

using UnityEngine.AddressableAssets;
using VContainer;
using VContainer.Unity;

public class SceneScopeLifetimeScope : LifetimeScope
{
    [SerializeField] private AssetReferenceGameObject dialogManagerRef;

    protected override void Configure(IContainerBuilder builder) { }

    protected override async void Build()
    {
        base.Build();

        // 1) Instantiate via Addressables
        var go = await dialogManagerRef.InstantiateAsync().Task;

        // 2) Ensure this scene scope is the parent for the child LifetimeScope
        using (LifetimeScope.EnqueueParent(this))
        {
            // 3) Build the child scope that lives on the prefab
            var child = go.GetComponent<LifetimeScope>();
            child.Build();
        }

        // 4) (Optional) Inject entire hierarchy if you have [Inject] methods
        //    and didn't register components via RegisterComponentInHierarchy in the child
        var childResolver = go.GetComponent<LifetimeScope>().Container;
        childResolver.InjectGameObject(go);
    }
}

Key points:

• Put the registrations that belong to the prefab inside the prefab’s scope (RegisterComponentInHierarchy<DialogManager>() etc.).
• Use CreateChildFromPrefab(...) when possible — it’s the simplest and matches the intended model.
• When using Addressables, EnqueueParent(this) + child.Build() gives you the same parent/child container relationship as Zenject’s GameObjectContext under a SceneContext.

Why this is “the VContainer way”

• VContainer prefers explicit injection/registration for MonoBehaviours (no global reflection sweep).
• Child scopes are first-class: they isolate “per-prefab” services while resolving shared dependencies from the parent.