VContainer

https://vcontainer.hadashikick.jp
Admin
VContainer is an extra fast and highly performant Dependency Injection (DI) framework for the Unity...
Tokens:35,110
Snippets:335
Trust Score:5.5
Update:9 months ago
Show doc for...
Tokens:
Raw
### Setup Entities with Default World (C#)

Source: https://vcontainer.hadashikick.jp/ja/integrations/ecs

An example demonstrating the setup of entities within an ECS system managed by VContainer's default world. This snippet shows how to create an archetype, spawn an entity, and schedule a job to process components using `Entities.ForEach`.

```csharp
public class GameLifetimeScope : LifetimeScope  
{
    protected override void Configure(IContainerBuilder builder)  
    {
        builder.UseDefaultWorld(systems =>  
        {
            systems.Add<SystemA>();  
        })
    }
}

public class SystemA : SystemBase  
{
    [Inject]  
    public void Construct(Foo foo)  
    {
        // Setup entities...
        var archtype = World.EntityManager.CreateArchetype(typeof(ComponentDataA));  
        World.EntityManager.CreateEntity(archtype);
    }
    protected override void OnUpdate()
    {
        Entities.ForEach((ref ComponentDataA data) =>  
            {
                // Do something...
            })
            .Schedule();
    }
}
```

--------------------------------

### Configure GameLifetimeScope for VContainer DI (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Configures the GameLifetimeScope to register GamePresenter as an entry point, HelloWorldService as a singleton, and the HelloScreen component. This setup ensures that VContainer manages the lifecycle and dependencies of these classes within the application, facilitating dependency injection.

```csharp
public class GameLifetimeScope : LifetimeScope
{
    [SerializeField]
    HelloScreen helloScreen;

    protected override void Configure(IContainerBuilder builder)
    {
        builder.RegisterEntryPoint<GamePresenter>();
        builder.Register<HelloWorldService>(Lifetime.Singleton);
        builder.RegisterComponent(helloScreen);
    }
}
```

--------------------------------

### Group Multiple EntryPoints Registration (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Demonstrates how to register multiple entry points using the 'UseEntryPoints' method in 'GameLifetimeScope' for better organization.

```csharp
using VContainer;
using VContainer.Unity;

namespace MyGame
{
    public class GameLifetimeScope : LifetimeScope
    {
        protected override void Configure(IContainerBuilder builder)
        {
            builder.Register<HelloWorldService>(Lifetime.Singleton);
            
            builder.UseEntryPoints(Lifetime.Singleton, entryPoints =>
            {
                entryPoints.Add<GamePresenter>();
            });
        }
    }
}

```

--------------------------------

### Define a Service Class in C#

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Creates a simple service class 'HelloWorldService' with a 'Hello' method that logs a message. This demonstrates a basic dependency that can be injected.

```csharp
namespace MyGame
{
    public class HelloWorldService
    {
        public void Hello()
        {
            UnityEngine.Debug.Log("Hello world");
        }
    }
}

```

--------------------------------

### Plain C# Entry Point Implementation

Source: https://vcontainer.hadashikick.jp/integrations/entrypoint

Demonstrates how to create a plain C# class that acts as an entry point, implementing the `IStartable` interface to define its start logic. This serves as a replacement for MonoBehaviour's `Start` method.

```csharp
class FooController : IStartable  
{
    void IStartable.Start()
    {
        // Do something ...
    }
}
```

--------------------------------

### Setup Entities with Default World VContainer (C#)

Source: https://vcontainer.hadashikick.jp/integrations/ecs

Provides an example of setting up an ECS system within VContainer's default world configuration. This snippet shows how to create an Entity with a specific archetype and schedule a job to process entities.

```csharp
public class GameLifetimeScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        builder.UseDefaultWorld(systems =>
        {
            systems.Add<SystemA>();
        })
    }
}
```

```csharp
public class SystemA : SystemBase
{
    [Inject]
    public void Construct(Foo foo)
    {
        // Setup entities...
        var archtype = World.EntityManager.CreateArchetype(typeof(ComponentDataA));
        World.EntityManager.CreateEntity(archtype);
    }
    protected override void OnUpdate()
    {
        Entities.ForEach((ref ComponentDataA data) =>
            {
                // Do something...
            })
            .Schedule();
    }
}
```

--------------------------------

### Custom Factory Class Example

Source: https://vcontainer.hadashikick.jp/ja/registering/register-factory

Demonstrates creating a custom factory class to manage instance creation. This approach ensures dependency resolution happens only once during factory initialization, not during instance creation.

```csharp
class FooFactory  
{
    private DependencyA dependencyA;

    public FooFactory(DependencyA dependencyA)
    {
        this.dependencyA = dependencyA;
    }

    public Foo Create() => new Foo(dependencyA);
}

// Usage example:
// var factory = new FooFactory(dependencyA); // Resolve required
// var foo1 = factory.Create(); // No Resolve
// var foo2 = factory.Create(); // No Resolve
// var foo3 = factory.Create(); // No Resolve
```

--------------------------------

### Register Plain C# Entry Point in VContainer

Source: https://vcontainer.hadashikick.jp/ja/integrations/entrypoint

This snippet demonstrates how to register a plain C# class implementing the `IStartable` interface as an entry point in VContainer. This allows the class's `Start()` method to be invoked within Unity's PlayerLoop cycle, similar to MonoBehaviour's Start function.

```csharp
class FooController : IStartable  
{
    void IStartable.Start()
    {
        // Do something ...
    }
}

builder.RegisterEntryPoint<FooController>();
```

--------------------------------

### Internal VContainer World and System Setup

Source: https://vcontainer.hadashikick.jp/integrations/ecs

Illustrates the internal setup VContainer performs when custom worlds and systems are registered. This includes creating the World, adding SystemGroups, and resolving/adding systems.

```csharp
// When resolving world ... 

var world = new World("My World 1");

world.CreateSystem<InitializationSystemGroup>();
world.CreateSystem<SimulationSystemGroup>();
world.CreateSystem<PresentationSystemGroup>();

ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world, PlayerLoop.GetCurrentPlayerLoop());

// Resolving dependencies ...
var systemA = new SystemA(new ServiceA());
world.AddSystem(systemA);

var systemGroup = (ComponentSystemGroup)world.GetOrCreateSystem<SimulationSystemGroup>();
systemGroup.AddSystemToUpdateList(systemA);


// After container build ... 

foreach (var system in world.Systems)
{
    if (system is ComponentSystemGroup group)
        group.SortSystems();
}
```

--------------------------------

### Setup Entities with Custom World in VContainer

Source: https://vcontainer.hadashikick.jp/integrations/ecs

Provides an example of setting up entities within a custom world managed by VContainer. This includes defining a LifetimeScope, configuring the world, and demonstrating entity creation and processing within a system.

```csharp
public class GameLifetimeScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        builder.UseNewWorld("My World 1", Lifetime.Scoped, systems =>
        {
            systems.Add<SystemA>();
        })
    }
}
```

```csharp
public class SystemA : SystemBase
{
    public void SystemA(Foo foo)
    {
        // Injected dependencies...
    }

    protected override void OnCreate()
    {
        // Setup entities...
        var archtype = World.EntityManager.CreateArchetype(typeof(ComponentDataA));
        World.EntityManager.CreateEntity(archtype);
    }

    protected override void OnUpdate()
    {
        Entities.ForEach((ref ComponentDataA data) =>
            {
                // Do something...
            })
            .Schedule();
    }
}
```

--------------------------------

### Register Dependencies in GameLifetimeScope (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Configures the VContainer dependency injection system by registering the 'HelloWorldService' as a singleton. This is done within a custom LifetimeScope class.

```csharp
using VContainer;
using VContainer.Unity;

namespace MyGame
{
    public class GameLifetimeScope : LifetimeScope
    {
        protected override void Configure(IContainerBuilder builder)
        {
            builder.Register<HelloWorldService>(Lifetime.Singleton);
        }
    }
}

```

--------------------------------

### Basic Constructor Injection Example

Source: https://vcontainer.hadashikick.jp/resolving/constructor-injection

Demonstrates a class with dependencies provided through its constructor. VContainer resolves these dependencies when an instance of the class is created. Note that optional dependencies are not supported in constructors.

```csharp
class ClassA  
{
    readonly IServiceA serviceA;
    readonly IServiceB serviceB;
    readonly SomeUnityComponent component;

    public ClassA(
        IServiceA serviceA,
        IServiceB serviceB,
        SomeUnityComponent component)
    {
        this.serviceA = serviceA;
        this.serviceB = serviceB;
        this.component = component;
    }
}
```

--------------------------------

### Define a Presenter Class with Constructor Injection (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Defines a 'GamePresenter' class that depends on 'HelloWorldService'. The dependency is injected via the constructor, showcasing Inversion of Control.

```csharp
using VContainer;
using VContainer.Unity;

namespace MyGame
{
    public class GamePresenter
    {
        readonly HelloWorldService helloWorldService;

        public GamePresenter(HelloWorldService helloWorldService)
        {
            this.helloWorldService = helloWorldService;
        }
    }
}

```

--------------------------------

### Update GamePresenter for VContainer DI (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Modifies the GamePresenter class to implement IStartable instead of ITickable, allowing for initialization logic to be executed once. It injects HelloWorldService and HelloScreen, and sets up an event listener for the HelloButton's click event to call the Hello method on HelloWorldService. This separates concerns by making GamePresenter solely responsible for control flow.

```csharp
namespace MyGame
{
    public class GamePresenter : IStartable
    {
        readonly HelloWorldService helloWorldService;
        readonly HelloScreen helloScreen;

        public GamePresenter(
            HelloWorldService helloWorldService,
            HelloScreen helloScreen)
        {
            this.helloWorldService = helloWorldService;
            this.helloScreen = helloScreen;
        }

        void IStartable.Start()
        {
            helloScreen.HelloButton.onClick.AddListener(() => helloWorldService.Hello());
        }
    }
}
```

--------------------------------

### Example Factory Class for Func<> Registration

Source: https://vcontainer.hadashikick.jp/registering/register-factory

This C# class `FooFactory` serves as an example for registering factory methods. It takes a dependency `DependencyA` in its constructor and has a `Create` method that instantiates a `Foo` object. This class illustrates a typical scenario where a factory needs specific dependencies to create objects.

```csharp
class FooFactory  
{
    public FooFactory(DependencyA dependencyA)  
    {
        this.dependencyA = dependencyA;
    }
  
    public Foo Create(int b) => new Foo(b, dependencyA);
}

```

--------------------------------

### Register GamePresenter as an EntryPoint (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Registers the 'GamePresenter' as an entry point in 'GameLifetimeScope', ensuring its 'Tick' method is called automatically during the Unity player loop.

```csharp
using VContainer;
using VContainer.Unity;

namespace MyGame
{
    public class GameLifetimeScope : LifetimeScope
    {
        protected override void Configure(IContainerBuilder builder)
        {
            builder.Register<HelloWorldService>(Lifetime.Singleton);
            builder.RegisterEntryPoint<GamePresenter>();
        }
    }
}

```

--------------------------------

### Basic VContainer Configuration with LifetimeScope

Source: https://vcontainer.hadashikick.jp/index

This C# code snippet demonstrates the basic setup of VContainer by defining a custom LifetimeScope. It shows how to register entry points, scoped services, singleton interfaces with their implementations, and components within the hierarchy. This configuration is essential for managing dependencies in a Unity application using VContainer.

```csharp
public class GameLifetimeScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        builder.RegisterEntryPoint<ActorPresenter>();

        builder.Register<CharacterService>(Lifetime.Scoped);
        builder.Register<IRouteSearch, AStarRouteSearch>(Lifetime.Singleton);

        builder.RegisterComponentInHierarchy<ActorsView>();
    }
}
```

--------------------------------

### Handling Uncaught Exceptions in Entry Points

Source: https://vcontainer.hadashikick.jp/integrations/entrypoint

Illustrates how to register a global exception handler for entry point methods like `Start()` and `Tick()`. This allows custom logic to be executed when an uncaught exception occurs within an entry point.

```csharp
builder.RegisterEntryPointExceptionHandler(ex =>
{
    // ...
});
```

--------------------------------

### Implement ITickable Interface for GamePresenter (C#)

Source: https://vcontainer.hadashikick.jp/getting-started/hello-world

Extends the 'GamePresenter' class to implement the 'ITickable' interface, allowing its 'Tick' method to be called automatically during Unity's player loop.

```csharp
using VContainer;
using VContainer.Unity;

namespace MyGame
{
    public class GamePresenter : ITickable
    {
        readonly HelloWorldService helloWorldService;

        public GamePresenter(HelloWorldService helloWorldService)
        {
            this.helloWorldService = helloWorldService;
        }

        void ITickable.Tick()
        {
            helloWorldService.Hello();
        }
    }
}

```

--------------------------------

### Create Child Scopes with LifetimeScope Prefab and Registrations

Source: https://vcontainer.hadashikick.jp/index

Demonstrates creating child LifetimeScopes dynamically. This includes creating a basic child scope, creating one from a prefab, and creating scopes with additional registrations either directly or via an installer. These methods are useful for managing resources during asynchronous loading operations.

```csharp
public void LoadLevel()  
{
    // ... Loading some assets  

    // Create a child scope  
    instantScope = currentScope.CreateChild();  

    // Create a child scope with LifetimeScope prefab  
    instantScope = currentScope.CreateChildFromPrefab(lifetimeScopePrefab);  

    // Create a child with additional registration  
    instantScope = currentScope.CreateChildFromPrefab(  
        lifetimeScopePrefab,  
        builder =>  
        {
            // Extra Registrations ...  
        });  

    instantScope = currentScope.CreateChild(builder =>  
    {
        // ExtraRegistrations ...  
    });  

    instantScope = currentScope.CreateChild(extraInstaller);  
}

public void UnloadLevel()  
{
    instantScope.Dispose();
}
```

--------------------------------

### Async Container Build with UniTask

Source: https://vcontainer.hadashikick.jp/optimization/async-container-build

Demonstrates how to manually build the VContainer lifetime scope asynchronously using UniTask after scene loading. This prevents the main thread from being blocked during the container build process. Ensure LifetimeScope.autoRun is set to false.

```csharp
var nextScene = await LoadSceneAsync(...);

var lifetimeScope = LifetimeScope.Find<MyLifetimeScope>(nextScene.Scene);

// Your async solution here.
await UniTask.Run(() => lifetimeScope.Build());
```

--------------------------------

### Handle Exceptions in Async Methods

Source: https://vcontainer.hadashikick.jp/ja/integrations/unitask

Provides an example of registering a global exception handler for entry points in VContainer. This allows for centralized management of exceptions that occur during asynchronous operations, unlike traditional coroutines.

```csharp
builder.RegisterEntryPointExceptionHandler(ex => ..)
```

--------------------------------

### Generated VContainer Injector Code Example (IL)

Source: https://vcontainer.hadashikick.jp/optimization/source-generator

This C# code snippet demonstrates the structure of an automatically generated injector class used by VContainer. It outlines how instances are created and dependencies are injected using the `IObjectResolver` and `IInjectParameter` interfaces. This is an example of what VContainer generates internally, not code to be directly written by the user.

```csharp
class ClassA  
{
    private sealed class __GeneratedInjector : IInjector
    {
        public object CreateInstance(IObjectResolver resolver, IReadOnlyList<IInjectParameter> parameters)
        {
            I6 fromConstructor = resolver.ResolveOrParameter<I6>("fromConstructor1", parameters);
            I7 fromConstructor2 = resolver.ResolveOrParameter<I7>("fromConstructor2", parameters);
            return new ClassA(fromConstructor, fromConstructor2);
        }

        public void Inject(object instance, IObjectResolver resolver, IReadOnlyList<IInjectParameter> parameters)
        {
            ClassA clasA = (ClassA)instance;
            I3 service = resolver.ResolveOrParameter<I3>("service3", parameters);
            I4 service2 = resolver.ResolveOrParameter<I4>("service4", parameters);
            allInjectionFeatureService.MethodInjectable1(service, service2);
            I5 service3 = resolver.ResolveOrParameter<I5>("service5", parameters);
            I6 service4 = resolver.ResolveOrParameter<I6>("service6", parameters);
            classA.MethodInjectable2(service3, service4);
            classA.PrivatePropertyInjectable = resolver.Resolve<I2>();
            classA.PublicPropertyInjectable = resolver.Resolve<I3>();
            classA.privateFieldInjectable = resolver.Resolve<I4>();
            classA.PublicFieldInjectable = resolver.Resolve<I5>();
       }
   }

}
```

--------------------------------

### Register Multiple Implementations with IReadOnlyList<T>

Source: https://vcontainer.hadashikick.jp/ja/registering/register-collection

Illustrates an alternative to using IEnumerable<T> for resolving multiple interface implementations. This example shows how to inject a collection of IDisposable services as an IReadOnlyList<IDisposable> into ClassA, offering a read-only collection.

```csharp
builder.Register<IDisposable, A>(Lifetime.Scoped);
builder.Register<IDisposable, B>(Lifetime.Scoped);
```

```csharp
class ClassA {
    public ClassA(IReadOnlyList<IDisposable> disposables) { /* ... */ }
}
```

--------------------------------

### Handling Unity-Dependent Registrations in Awake

Source: https://vcontainer.hadashikick.jp/optimization/async-container-build

Illustrates how to handle VContainer registrations that depend on Unity features (e.g., `RegisterComponentInHierarchy`) by performing them in the Awake method. This ensures these operations run on the main thread, preventing errors when other parts of the build are executed asynchronously.

```csharp
class GameLifetimeScope : LifetimeScope
{
    Ground groundInScene;

    protected override void Awake()
    {
        // Run main thread.
        groundInScene = FindObjectOfType<Ground>();

        base.Awake();
    }

    protected override void Configure(IContainerBuilder builder)
    {
        // This can run on a background thread now.
        builder.RegisterInstance(groundInScene);
    }
}
```

--------------------------------

### Register Custom Exception Handler for Entry Points

Source: https://vcontainer.hadashikick.jp/ja/integrations/entrypoint

This C# code shows how to register a custom exception handler for unhandled exceptions occurring in VContainer entry point processes (like Start() or Tick()). When registered, this callback will be invoked instead of the default logging behavior for exceptions.

```csharp
builder.RegisterEntryPointExceptionHandler(ex =>
{
    // Handle the exception, e.g., log it customly
});
```

--------------------------------

### Registering an Instance with VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Shows how to register a pre-existing object instance. VContainer uses RegisterInstance(), while Zenject uses BindInstance().

```csharp
builder.RegisterInstance(obj);
```

```csharp
Container.BindInstance(obj);
```

--------------------------------

### Registering Func<> Factory with Runtime Parameters

Source: https://vcontainer.hadashikick.jp/registering/register-factory

This snippet demonstrates registering a factory method that acts as a `Func<>` delegate. The factory itself is registered, and then a `Func<>` is created from its `Create` method. This allows you to resolve and use the factory as a simple function, abstracting away the factory class implementation.

```csharp
builder.Register<FooFactory>(Lifetime.Singleton);
builder.RegisterFactory(container => container.Resolve<FooFactory>().Create, Lifetime.Singleton);

// ...  

var factory = container.Resolve<Func<int, Foo>>();

var foo1 = factory(1);
var foo2 = factory(2);
var foo3 = factory(3);

var originalFactoryObject = container.Resolve<FooFactory>(); // The factory object is there if you need it.  
// If FooFactory implements IDisposable, it'll be called when the IObjectResolver is disposed.  
```

--------------------------------

### Schedule Async Execution with PlayerLoopTiming

Source: https://vcontainer.hadashikick.jp/integrations/unitask

Illustrates how to control the execution timing of asynchronous operations within StartAsync using UniTask's PlayerLoopTiming. This allows scheduling tasks for specific Unity PlayerLoop phases.

```csharp
await UniTask.Yield(PlayerLoopTiming.FixedUpdate);
```

--------------------------------

### Suppressing IDE Warnings with [UsedImplicitly]

Source: https://vcontainer.hadashikick.jp/resolving/constructor-injection

Provides an example of using the [UsedImplicitly] attribute with specific flags to prevent IDEs like Rider from marking constructors or methods as unused when they are implicitly invoked by VContainer.

```csharp
public class Dependency
{
    [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
    public Dependency(GameContext game, StatusContext status)
    {
        _game = game;
    }
}
// This class and constructor will not be marked as unused, but the status parameter will be.
```

--------------------------------

### Factory with Prefab: Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Demonstrates how to bind a factory for an Enemy prefab in Zenject. It uses `PlaceholderFactory<Enemy>` and `FromComponentInNewPrefab` to create instances of the Enemy prefab, injecting dependencies like 'Player' via the constructor.

```csharp
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);
```

--------------------------------

### Register Multiple Interfaces with Integer Keys in C#

Source: https://vcontainer.hadashikick.jp/ja/registering/register-with-keys

Shows how to register multiple implementations of an interface (ILevel) using integer values as keys. This method is practical for differentiating between sequential or numerical categories, such as different game levels.

```csharp
builder.Register<ILevel, Level1>(Lifetime.Singleton)
    .Keyed(1);

builder.Register<ILevel, Level2>(Lifetime.Singleton)
    .Keyed(2);
```

--------------------------------

### Registering Instance with Lambda Expression (C#)

Source: https://vcontainer.hadashikick.jp/registering/register-using-delegate

This snippet shows how to register an instance of `IFoo` using a lambda expression. The lambda creates a new `Foo` object and optionally performs some setup before returning it. The registration is set to `Lifetime.Scoped`.

```csharp
builder.Register<IFoo>(_ =>  
{
    var foo = new Foo();
    // Do something;
    return foo;
}, Lifetime.Scoped);

```

--------------------------------

### Registering Component from Prefab in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Demonstrates registering a component by instantiating it from a prefab. VContainer uses RegisterComponentInNewPrefab(prefab, Lifetime.Scoped), while Zenject uses Bind<T>().FromComponentInNewPrefab(prefab).AsCached().

```csharp
builder.RegisterComponentInNewPrefab(prefab, Lifetime.Scoped);
```

```csharp
Container.Bind<Foo>().FromComponentInNewPrefab(prefab).AsCached();
```

--------------------------------

### Resolving Registered Instance in a Class (C#)

Source: https://vcontainer.hadashikick.jp/registering/register-using-delegate

This example demonstrates how a class, `ClassA`, can resolve the `IFoo` dependency registered via a delegate. The `IFoo` instance is injected through the constructor, showcasing Autofac's dependency injection capabilities.

```csharp
class ClassA  
{
    public ClassA(IFoo foo) { /* ...*/ }
}

```

--------------------------------

### Using Key Attribute for Specific Implementations

Source: https://vcontainer.hadashikick.jp/resolving/constructor-injection

Illustrates how to use the [Key] attribute in a constructor to inject specific implementations of an interface or type that have been registered with corresponding keys in the VContainer.

```csharp
class TestClass
{
    private readonly IWeapon _primaryWeapon;
    private readonly IEnemy _goblin;
    private readonly ILevel _level1;

    public TestClass(
        [Key(WeaponType.Primary)] IWeapon primaryWeapon,
        [Key("goblin")] IEnemy goblin,
        [Key(1)] ILevel level1)
    {
        _primaryWeapon = primaryWeapon;
        _goblin = goblin;
        _level1 = level1;
    }
}
```

--------------------------------

### Register ECS System with VContainer (C#)

Source: https://vcontainer.hadashikick.jp/integrations/ecs

Demonstrates how to register an ECS System (inheriting from SystemBase) with VContainer for dependency injection. This allows VContainer to manage the system's lifecycle and inject dependencies into its constructor. It requires the 'com.unity.entities' package to be installed.

```csharp
class SystemA : SystemBase
{
    [Inject]
    public void Construct(Settings settings)
    {
        // ...
    }

    protected override void OnUpdate()
    {
        // ...
    }

}
```

```csharp
// Inject the `System` to Unity's default World
builder.RegisterSystemFromDefaultWorld<SystemA>();

// builder.RegisterSystemFromDefaultWorld<SystemB>();
// builder.RegisterSystemFromDefaultWorld<SystemC>();

// Other dependencies can be injected into the System.
builder.RegisterInstance(settings);
// ...
```

```csharp
builder.UseDefaultWorld(systems =>
{
    systems.Add<SystemA>();

    // systems.Add<SystemB>();
    // systems.Add<SystemC>();
    // ...
});
```

```csharp
var system = World.DefaultGameObjectInjectionWorld.GetExistingSystem<SystemA>();
system.Construct(settings);
```

--------------------------------

### Register Factory for Instantiating Prefabs with VContainer

Source: https://vcontainer.hadashikick.jp/registering/register-factory

Demonstrates a factory registration pattern for instantiating prefabs, commonly used in game development. The factory resolves dependencies from the container and uses `container.Instantiate` to create objects from prefabs, managing their lifetime within a specific scope.

```csharp
builder.RegisterFactory<CharacterType, CharacterActor>(container => {
    return characterType => {
        var characterPrefab = ...
        return container.Instantiate(characterPrefab, parentTransform);
    }
}, Lifetime.Scoped);
```

--------------------------------

### Register Func<> Factory using container.Instantiate

Source: https://vcontainer.hadashikick.jp/ja/registering/register-factory

Demonstrates using VContainer's `container.Instantiate` method within a Func<> factory registration. This is useful for creating instances from prefabs or other complex scenarios, often combined with a specified lifetime.

```csharp
builder.RegisterFactory<CharacterType, CharacterActor>(container =>
{
    return characterType =>
    {
        var characterPrefab = ...;
        return container.Instantiate(characterPrefab, parentTransform);
    };
}, Lifetime.Scoped);
```

--------------------------------

### Generate Child Scopes in C# using vcontainer

Source: https://vcontainer.hadashikick.jp/ja/scoping/generate-child-with-code-first

Demonstrates how to programmatically create child scopes from a parent LifetimeScope in C#. This includes creating scopes directly, from prefabs, and with custom registrations or installers. The child scope manages its own lifetime and can be disposed to release resources.

```csharp
class LevelLoader  
{
    readonly LifetimeScope currentScope;

    LifetimeScope instantScope;

    public LevelLoader(LifetimeScope lifetimeScope)
    {
        currentScope = lifetimeScope;
    }

    public void Load()
    {
        // ... Loading some assets with any async way you like
        //
        // await Addressables.LoadAssetAsync...
        //

        // Create a child scope for the container that contains this LevelLoader instance.
        instantScope = currentScope.CreateChild();

        // Create with LifetimeScope prefab
        instantScope = currentScope.CreateChildFromPrefab(
            lifetimeScopePrefab);

        // Create with LifetimeScope prefab and extra registrations
        instantScope = currentScope.CreateChildFromPrefab(
            lifetimeScopePrefab, builder =>
            {
                builder.RegisterInstance(someExtraAsset);
                builder.RegisterEntryPoint<ExtraEntryPoint>();
                // ...
            });

        // Create a child scope with extra registrations
        instantScope = currentScope.CreateChild(builder =>
        {
            // ...
        });

        // Create a child scope with extra registrations via `IInstaller`
        instantScope = currentScope.CreateChild(extraInstaller);


        // The additionally registered entry point runs immediately after the scope is created...

        // Or you can use scoped instance directly.
        var foo = instantScope.Container.Resolve<Foo>();
    }

    public void Unload()
    {
        // Note that the scope implicitly create `LifetimeScope`.
        // Use `Dispose` to safely destroying the scope.
        instantScope.Dispose();

        // ... Unloading some assets
    }
}
```

--------------------------------

### Implement IAsyncStartable with UniTask

Source: https://vcontainer.hadashikick.jp/integrations/unitask

Demonstrates how to implement the IAsyncStartable interface using UniTask for asynchronous initialization. The StartAsync method returns a UniTask and accepts a CancellationToken.

```csharp
public class FooController : IAsyncStartable  
{
    public async UniTask StartAsync(CancellationToken cancellation)  
    {
        await LoadSomethingAsync(cancellation);
        await ...
        ...
    }
}
```

--------------------------------

### Registering an Instance as Implemented Interfaces in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Shows how to register an instance that should be resolved via its implemented interfaces. VContainer uses RegisterInstance(obj).AsImplementedInterfaces(), while Zenject uses BindInterfacesTo<Service>().FromInstance(obj).

```csharp
builder.RegisterInstance(obj).AsImplementedInterfaces();
```

```csharp
Container.BindInterfacesTo<Service>().FromInstance(obj);
```

--------------------------------

### Registering an Instance as Implemented Interfaces and Self in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Illustrates registering an instance that can be resolved both by its implemented interfaces and its own type. VContainer uses RegisterInstance(obj).AsImplementedInterfaces().AsSelf(), while Zenject uses BindInterfacesAndSelfTo<Service>().FromInstance(obj).

```csharp
builder.RegisterInstance(obj).AsImplementedInterfaces().AsSelf();
```

```csharp
Container.BindInterfacesAndSelfTo<Service>().FromInstance(obj);
```

--------------------------------

### Marking Constructor with [Inject] Attribute

Source: https://vcontainer.hadashikick.jp/resolving/constructor-injection

Shows how to use the [Inject] attribute on a constructor to ensure it's not stripped by Unity's build process and to designate it as the constructor for dependency injection when multiple constructors exist.

```csharp
    [Inject]
    public ClassA(
        IServiceA serviceA,
        IServiceB serviceB,
        SomeUnityComponent component)
    {
        // ...
    }
```

--------------------------------

### VContainer Generated IL Code Example

Source: https://vcontainer.hadashikick.jp/ja/optimization/codegen

This snippet demonstrates the IL code automatically generated by VContainer for meta-programming. It includes an `__GeneratedInjector` class that implements `IInjector` for creating instances and injecting dependencies without using reflection at runtime. This generated code is crucial for achieving the performance benefits of VContainer.

```csharp
class ClassA  
{
    private sealed class __GeneratedInjector : IInjector  
    {
        public object CreateInstance(IObjectResolver resolver, IReadOnlyList<IInjectParameter> parameters)
        {
            I6 fromConstructor = resolver.ResolveOrParameter<I6>("fromConstructor1", parameters);
            I7 fromConstructor2 = resolver.ResolveOrParameter<I7>("fromConstructor2", parameters);
            return new ClassA(fromConstructor, fromConstructor2);
        }

        public void Inject(object instance, IObjectResolver resolver, IReadOnlyList<IInjectParameter> parameters)
        {
            ClassA clasA = (ClassA)instance;
            I3 service = resolver.ResolveOrParameter<I3>("service3", parameters);
            I4 service2 = resolver.ResolveOrParameter<I4>("service4", parameters);
            allInjectionFeatureService.MethodInjectable1(service, service2);
            I5 service3 = resolver.ResolveOrParameter<I5>("service5", parameters);
            I6 service4 = resolver.ResolveOrParameter<I6>("service6", parameters);
            classA.MethodInjectable2(service3, service4);
            classA.PrivatePropertyInjectable = resolver.Resolve<I2>();
            classA.PublicPropertyInjectable = resolver.Resolve<I3>();
            classA.privateFieldInjectable = resolver.Resolve<I4>();
            classA.PublicFieldInjectable = resolver.Resolve<I5>();
        }
   }

}
```

--------------------------------

### Accessing Container and Resolving Dependencies with IObjectResolver (C#)

Source: https://vcontainer.hadashikick.jp/resolving/container-api

Demonstrates how to obtain and use IObjectResolver to resolve services by type, with specific keys, perform safe resolutions, inject dependencies into objects and GameObjects, and instantiate prefabs with VContainer.

```csharp
class ClassA  
{
    public ClassA(IObjectResolver container)  
    {
        // Get (or create) whatever is registered as ServiceA.
        var serviceA = container.Resolve<ServiceA>();  

        // Resolve with a key
        var primaryWeapon = container.Resolve<IWeapon>(WeaponType.Primary);
        var secondaryWeapon = container.Resolve<IWeapon>(WeaponType.Secondary);

        // Try resolve with a key
        if (container.TryResolve<IWeapon>(WeaponType.Special, out var specialWeapon))
        {
            // Use specialWeapon
        }

        // Inject dependencies into an object
        container.Inject(foo);

        // Inject dependencies into GameObjects and their descendents
        container.InjectGameObject(gameObject);

        // Instantiate a GameObject from a prefab and inject dependencies
        var object1 = container.Instantiate(prefab);
        var object2 = container.Instantiate(prefab, parent);
        var object3 = container.Instantiate(prefab, position, rotation, parent);
    }
}
```

--------------------------------

### Registering a Single Instance for Multiple Interfaces in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Demonstrates registering one instance that implements multiple interfaces. VContainer uses RegisterInstance(obj).As<T1, T2>(), while Zenject uses Bind() with multiple interface types and FromInstance(obj).

```csharp
builder.RegisterInstance(obj).As<IService1, IService2>();
```

```csharp
Container.Bind(typeof(IService1), typeof(IService2)).FromInstance(obj);
```

--------------------------------

### Manual ECS System Retrieval and Construction (C#)

Source: https://vcontainer.hadashikick.jp/ja/integrations/ecs

Illustrates the internal process that VContainer automates for registering ECS systems. This snippet shows how to manually retrieve an existing system from the default ECS world and construct it with dependencies, which is what `RegisterSystemFromDefaultWorld` effectively does.

```csharp
var system = World.DefaultGameObjectInjectionWorld.GetExistingSystem<SystemA>();  
system.Construct(settings);
```

--------------------------------

### Register Func<> Factory with Runtime Parameters

Source: https://vcontainer.hadashikick.jp/ja/registering/register-factory

Shows how to register a Func<> delegate for instance creation that only requires runtime parameters. VContainer allows registering a Func<> that takes a parameter and returns an instance.

```csharp
builder.RegisterFactory<int, Foo>(x => new Foo(x));

// Resolution example:
// class ClassA
// {
//     readonly Func<int, Foo> factory;
//
//     public ClassA(Func<int, Foo> factory)
//     {
//         this.factory = factory;
//     }
//
//     public void DoSomething()
//     {
//         var foo = factory.Invoke(100);
//     }
// }
```

--------------------------------

### Instantiating Prefabs with Injection - C#

Source: https://vcontainer.hadashikick.jp/ja/registering/register-using-delegate

Register a type using a delegate that leverages IObjectResolver.Instantiate to create a GameObject from a prefab, ensuring that injected dependencies are resolved.

```csharp
builder.Register(container =>
{
    return container.Instantiate(prefab);
}, Lifetime.Scoped);
  

```

--------------------------------

### Register Multiple Interfaces with String Keys in C#

Source: https://vcontainer.hadashikick.jp/ja/registering/register-with-keys

Illustrates registering different implementations of an interface (IEnemy) using string values as keys. This approach is suitable for scenarios where string identifiers are more convenient, such as differentiating between enemy types by name.

```csharp
builder.Register<IEnemy, Goblin>(Lifetime.Singleton)
    .Keyed("goblin");

builder.Register<IEnemy, Orc>(Lifetime.Singleton)
    .Keyed("orc");
```

--------------------------------

### Register Multiple Implementations with IEnumerable<T>

Source: https://vcontainer.hadashikick.jp/ja/registering/register-collection

Demonstrates how to register multiple implementations for a single interface (IDisposable) and resolve them within a class (ClassA) using IEnumerable<IDisposable>. This allows for injecting collections of related services.

```csharp
builder.Register<IDisposable, A>(Lifetime.Scoped);
builder.Register<IDisposable, B>(Lifetime.Scoped);
```

```csharp
class ClassA {
    public ClassA(IEnumerable<IDisposable> disposables) { /* ... */ }
}
```

--------------------------------

### Registering an Instance as a Specific Interface in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Illustrates registering an instance that should be resolved as a specific interface type. VContainer uses RegisterInstance<IService>(obj), whereas Zenject uses Bind<IService>().FromInstance(obj).

```csharp
builder.RegisterInstance<IService>(obj);
```

```csharp
Container.Bind<IService>().FromInstance(obj);
```

--------------------------------

### Factory with Parameter and Runtime Dependency Resolution in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Shows how to create factories where dependencies are resolved at runtime. VContainer's RegisterFactory lambda receives the container to resolve dependencies, while Zenject's PlaceholderFactory requires manual handling or specific binding configurations.

```csharp
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);
```

```csharp
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>();
```

--------------------------------

### Registering New Component on New GameObject in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Illustrates creating a new GameObject and adding a component to it. VContainer uses RegisterComponentOnNewGameObject<T>(Lifetime.Scoped, "Name").UnderTransform(parent), while Zenject uses Bind<T>().FromNewComponentOnNewGameObject().AsCached().WithGameObjectName("Name").UnderTransform(parent).

```csharp
builder.RegisterComponentOnNewGameObject<Foo>(Lifetime.Scoped, "Foo1").UnderTransform(parentTransform);
```

```csharp
Container.Bind<Foo>().FromNewComponentOnNewGameObject().AsCached().WithGameObjectName("Foo1").UnderTransform(parentTransform);
```

--------------------------------

### Register Multiple Interfaces with Enum Keys in C#

Source: https://vcontainer.hadashikick.jp/ja/registering/register-with-keys

Demonstrates how to register multiple implementations of an interface (IWeapon) using different enum values as keys. This is useful when you have distinct types of the same conceptual object, like different weapon types, and need to inject specific ones.

```csharp
public enum WeaponType
{
    Primary,
    Secondary,
    Special
}

builder.Register<IWeapon, Sword>(Lifetime.Singleton)
    .Keyed(WeaponType.Primary);

builder.Register<IWeapon, Bow>(Lifetime.Singleton)
    .Keyed(WeaponType.Secondary);

builder.Register<IWeapon, MagicStaff>(Lifetime.Singleton)
    .Keyed(WeaponType.Special);
```

--------------------------------

### IObjectResolver Usage

Source: https://vcontainer.hadashikick.jp/resolving/container-api

Demonstrates how to obtain and use the IObjectResolver to resolve dependencies, resolve with keys, inject objects, and instantiate prefabs.

```APIDOC
## IObjectResolver API

### Description
Provides direct access to the DI container for resolving dependencies, injecting objects, and instantiating prefabs. `IObjectResolver` is automatically registered and can be injected like any other dependency.

### Method
N/A (This is a conceptual API usage demonstration)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```csharp
class ClassA  
{
    public ClassA(IObjectResolver container)
    {
        // Resolve a registered service
        var serviceA = container.Resolve<ServiceA>();

        // Resolve with a specific key
        var primaryWeapon = container.Resolve<IWeapon>(WeaponType.Primary);

        // Try to resolve with a key, returning true if successful
        if (container.TryResolve<IWeapon>(WeaponType.Special, out var specialWeapon))
        {
            // Use specialWeapon
        }

        // Inject dependencies into an object
        container.Inject(foo);

        // Inject dependencies into MonoBehaviours of a GameObject and its children
        container.InjectGameObject(gameObject);

        // Instantiate a prefab and inject its MonoBehaviours
        var object1 = container.Instantiate(prefab);

        // Instantiate a prefab with position and rotation
        var object3 = container.Instantiate(prefab, position, rotation, parent);
    }
}
```

### Response
N/A (This is a code example demonstrating usage)

```

--------------------------------

### Factory with Parameter in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Compares the implementation of factories that accept a parameter during instantiation. VContainer uses RegisterFactory with a lambda that creates the object, while Zenject uses a PlaceholderFactory and BindFactory.

```csharp
public class Enemy
{
    readonly float speed;

    public Enemy(float speed)
    {
        this.speed = speed;
    }
}

builder.RegisterFactory<float, Enemy>(speed => new Enemy(speed));
```

```csharp
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>();
```

--------------------------------

### Registering a Scoped Service and Its Implemented Interfaces in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Demonstrates registering a service that implements interfaces and also allows itself to be resolved directly, with a scoped lifetime. VContainer uses Register with AsImplementedInterfaces().AsSelf(), while Zenject uses BindInterfacesAndSelfTo<Service>().AsCached().

```csharp
builder.Register<Service>(Lifetime.Scoped).AsImplementedInterfaces().AsSelf();
```

```csharp
Container.BindInterfacesAndSelfTo<Service>().AsCached();
```

--------------------------------

### Register Factory Class with VContainer

Source: https://vcontainer.hadashikick.jp/registering/register-factory

Demonstrates registering a custom factory class with VContainer. The factory class itself can have dependencies injected and provides a method to create instances of another type. The factory is registered as a singleton, and its creation method is called later.

```csharp
class FooFactory {
    public FooFactory(DependencyA dependencyA) {
        this.dependencyA = dependencyA;
    }

    public Foo Create(int b) => new Foo(b, dependencyA);
}

builder.Register<FooFactory>(Lifetime.Singleton);

// ...

var factory = container.Resolve<FooFactory>();

// ...

var foo1 = factory.Create(1);
var foo2 = factory.Create(2);
var foo3 = factory.Create(3);
```

--------------------------------

### Inject World Dependency (C#)

Source: https://vcontainer.hadashikick.jp/integrations/ecs

Demonstrates how to inject the 'World' object into a class constructor in C#. Covers scenarios with a single registered world and multiple registered worlds, including how to select a specific world by name when multiple are present. This relies on a dependency injection system.

```csharp
class ClassA
{
    public ClassA(World world) { /* ... */ }
}

class ClassA
{
    public ClassA(IEnumerable<World> worlds)
    {
        var world = worlds.First(x => x.Name == "My new world");
        // ...
    }
}
```

--------------------------------

### Registering Multiple Interfaces for a Scoped Service in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Illustrates registering a single service implementation that fulfills multiple interfaces with a scoped lifetime. VContainer uses Register with As<T1, T2>() or AsImplementedInterfaces(), while Zenject uses Bind() with multiple interface types and To<Service>().AsCached().

```csharp
builder.Register<Service>(Lifetime.Scoped).As<IInitializable, IDisposable>();
```

```csharp
Container.Bind(typeof(IInitializable), typeof(IDisposable)).To<Service>().AsCached();
```

--------------------------------

### Register Entry Point Exception Handler

Source: https://vcontainer.hadashikick.jp/integrations/unitask

Explains how to register a global exception handler for entry points within a LifetimeScope. This allows for centralized error management of asynchronous operations.

```csharp
builder.RegisterEntryPointExceptionHandler(ex => { /* handle exception */ });
```

--------------------------------

### Registering Services with Different Lifetimes in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Demonstrates how to register services with transient, scoped, and singleton lifetimes using VContainer's builder API compared to Zenject's Bind API. VContainer uses the Register method with a Lifetime enum, while Zenject uses Bind with AsTransient, AsCached, or AsSingle.

```csharp
builder.Register<Service>(Lifetime.Transient);
builder.Register<Service>(Lifetime.Scoped);
builder.Register<Service>(Lifetime.Singleton);
```

```csharp
Container.Bind<Service>().AsTransient();
Container.Bind<Service>().AsCached();
Container.Bind<Service>().AsSingle();
```

--------------------------------

### Registering Component from Hierarchy in VContainer vs. Zenject

Source: https://vcontainer.hadashikick.jp/comparing/comparing-to-zenject

Shows how to register a component found in the scene's hierarchy. VContainer uses RegisterComponentInHierarchy<T>(), while Zenject uses Bind<T>().FromComponentInHierarchy().AsCached().

```csharp
builder.RegisterComponentInHierarchy<Foo>();
```

```csharp
Container.Bind<Foo>().FromComponentInHierarchy().AsCached();
```

--------------------------------

### Resolve Keyed Registrations with Key Attribute in C#

Source: https://vcontainer.hadashikick.jp/ja/registering/register-with-keys

Demonstrates how to resolve specifically registered implementations using the `[Key]` attribute in constructor injection. This allows the dependency injection container to provide the correct instance based on the key provided.

```csharp
class WeaponSystem
{
    public WeaponSystem(
        [Key(WeaponType.Primary)] IWeapon primaryWeapon,
        [Key(WeaponType.Secondary)] IWeapon secondaryWeapon)
    {
        // ...
    }
}
```

--------------------------------

### 次シーンへの追加レジストリの登録 - C#

Source: https://vcontainer.hadashikick.jp/ja/scoping/generate-child-via-scene

ロードされるシーンにレジストリを追加する方法を説明します。LifetimeScope.Enqueueを使用することで、ロード中のシーンにカスタムレジストリやインスタンスを登録できます。これは、非同期でアセットがロードされた後などにコンテキストを最終化したい場合に便利です。

```csharp
// LifetimeScopes generated during this block will be additionally Registered.  
using (LifetimeScope.Enqueue(builder =>  
{
    // Register for the next scene not yet loaded  
    builder.RegisterInstance(extraInstance);
}))  
{
    // Loading the scene..
}
```

```csharp
// Use registration as type  
class FooInstaller : IInstaller  
{
    public void Install(IContainerBuilder builder)  
    {
        builder.Register<ExtraType>(Lifetime.Scoped);
    }
}

using (LifetimeScope.Enqueue(fooInstaller)
{
    // ... loading scene
}
```

```csharp
// EnqueueParent() and Enqueue() can be used together.  
using (LifetimeScope.EnqueueParent(parent))
using (LifetimeScope.Enqueue(builder => ...)
{
    // ... loading scene
}
```

--------------------------------

### Register Simple Func<> Factory in VContainer

Source: https://vcontainer.hadashikick.jp/registering/register-factory

Shows how to register a simple factory function using a lambda expression for types that do not require additional dependencies. This factory takes a runtime parameter and creates a new instance of the target type.

```csharp
builder.RegisterFactory<int, Foo>(x => new Foo(x));

// Usage:
class ClassA {
    readonly Func<int, Foo> factory;

    public ClassA(Func<int, Foo> factory) {
        this.factory = factory;
    }

    public void DoSomething() {
        var foo = factory(100);
        // ...
    }
}
```
Tokens:
Raw