# Unity Vcontainer

> VContainer dependency injection expert specializing in IoC container configuration, lifecycle management, and Unity-optimized DI patterns. Masters dependency resolution, scoped containers, and testable architecture design. Use PROACTIVELY for VContainer setup, service registration, or SOLID principle implementation.

- Skill: `creator-hian/unity-vcontainer` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add creator-hian/unity-vcontainer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/creator-hian/unity-vcontainer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: creator-hian (https://skillmd.com/u/creator-hian)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/creator-hian/unity-vcontainer

---


# Unity VContainer - High-Performance DI for Unity

## Overview

VContainer is a high-performance IoC container for Unity, providing dependency injection patterns for testable and maintainable code.

**Core Topics**:
- Constructor and method injection
- Service registration patterns (Singleton, Transient, Scoped)
- LifetimeScope hierarchies
- MonoBehaviour injection
- Factory patterns with DI
- Testing with mocks

**Foundation Required**: `unity-csharp-fundamentals` (TryGetComponent, FindAnyObjectByType, null-safe coding)

**Learning Path**: DI fundamentals → VContainer basics → Advanced patterns → Testing

## Quick Start

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

// Define service interface
public interface IPlayerService
{
    void Initialize();
}

// Implement service
public class PlayerService : IPlayerService
{
    public void Initialize() => Debug.Log("Player initialized");
}

// Setup LifetimeScope
public class GameLifetimeScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<IPlayerService, PlayerService>(Lifetime.Singleton);
        builder.RegisterComponentInHierarchy<PlayerController>();
    }
}

// Inject into MonoBehaviour
public class PlayerController : MonoBehaviour
{
    [Inject] private readonly IPlayerService mPlayerService;

    void Start() => mPlayerService.Initialize();
}
```

## Key Concepts

### Lifetime Scopes
- **Singleton**: One instance per container
- **Transient**: New instance every resolve
- **Scoped**: One instance per scope

### Injection Types
- **Constructor Injection**: Preferred for required dependencies
- **Method Injection**: For optional dependencies
- **Property/Field Injection**: Use `[Inject]` attribute

## Reference Documentation

### [VContainer Best Practices](references/vcontainer-patterns.md)
Core DI patterns:
- Registration patterns and lifetime management
- LifetimeScope hierarchies
- Testing with mock dependencies

### [VContainer Integration Patterns](references/vcontainer-integrations.md)
Advanced integrations:
- MVVM with reactive properties
- Cross-framework integration patterns

## Best Practices

1. **Register interfaces**: Loose coupling and testability
2. **Constructor injection first**: Explicit dependencies
3. **Avoid Service Locator**: Don't resolve in Update loops
4. **Test with mocks**: Use ContainerBuilder in tests
5. **Clear hierarchies**: Root → Scene → Local scopes