com.wallstop-studios.unity-helpers 2.0.0-rc81.9 → 2.0.1

package/Samples~/DI - VContainer/Scripts/Spawner.cs

@@ -2,20 +2,129 @@ namespace Samples.UnityHelpers.DI.VContainer
 {
     using global::VContainer;
     using UnityEngine;
+    using UnityEngine.Pool;
     using WallstopStudios.UnityHelpers.Integrations.VContainer;
 
     public sealed class Spawner : MonoBehaviour
     {
         [SerializeField]
-        private RelationalConsumer _prefab;
+        private RelationalConsumer _componentPrefab;
+
+        [SerializeField]
+        private GameObject _hierarchyPrefab;
+
+        [SerializeField]
+        private Transform _defaultParent;
 
         [Inject]
         private IObjectResolver _resolver;
 
-        public RelationalConsumer Build(Transform parent)
+        private ObjectPool<RelationalConsumer> _componentPool;
+
+        private void Awake()
+        {
+            _componentPool = RelationalObjectPools.CreatePoolWithRelations(
+                createFunc: () => Instantiate(_componentPrefab),
+                actionOnGet: OnGetFromPool,
+                actionOnRelease: OnReleaseToPool
+            );
+        }
+
+        /// <summary>
+        /// Instantiate a component prefab through VContainer so dependencies and relational fields
+        /// are populated in one call.
+        /// </summary>
+        public RelationalConsumer SpawnComponent(Transform parent)
+        {
+            Transform targetParent = parent != null ? parent : _defaultParent;
+            RelationalConsumer instance = _resolver.InstantiateComponentWithRelations(
+                _componentPrefab,
+                targetParent
+            );
+            return instance;
+        }
+
+        /// <summary>
+        /// Instantiate a hierarchy prefab and hydrate every attributed component beneath it.
+        /// </summary>
+        public GameObject SpawnHierarchy(Transform parent)
+        {
+            Transform targetParent = parent != null ? parent : _defaultParent;
+            GameObject root = _resolver.InstantiateGameObjectWithRelations(
+                _hierarchyPrefab,
+                targetParent,
+                includeInactiveChildren: true
+            );
+            return root;
+        }
+
+        /// <summary>
+        /// Rent a component from a simple pool, then inject and assign it through the resolver.
+        /// </summary>
+        public RelationalConsumer SpawnFromPool(Transform parent)
+        {
+            Transform targetParent = parent != null ? parent : _defaultParent;
+            RelationalConsumer instance = _componentPool.GetWithRelations(_resolver);
+            if (targetParent != null)
+            {
+                instance.transform.SetParent(targetParent, false);
+            }
+            return instance;
+        }
+
+        /// <summary>
+        /// Return an instance to the pool.
+        /// </summary>
+        public void ReturnToPool(RelationalConsumer instance)
+        {
+            if (instance == null)
+            {
+                return;
+            }
+
+            _componentPool.Release(instance);
+        }
+
+        /// <summary>
+        /// Hydrate an existing hierarchy that was created outside of the resolver (e.g., scene tools).
+        /// </summary>
+        public void HydrateExistingHierarchy(GameObject root)
+        {
+            if (root == null)
+            {
+                return;
+            }
+
+            _resolver.AssignRelationalHierarchy(root, includeInactiveChildren: true);
+        }
+
+        private void OnGetFromPool(RelationalConsumer consumer)
+        {
+            if (consumer == null)
+            {
+                return;
+            }
+
+            consumer.gameObject.SetActive(true);
+        }
+
+        private void OnReleaseToPool(RelationalConsumer consumer)
+        {
+            if (consumer == null)
+            {
+                return;
+            }
+
+            consumer.gameObject.SetActive(false);
+        }
+
+        private void OnDestroy()
         {
-            RelationalConsumer instance = Instantiate(_prefab, parent);
-            return _resolver.BuildUpWithRelations(instance);
+            if (_componentPool != null)
+            {
+                _componentPool.Clear();
+                _componentPool = null;
+            }
         }
     }
 }

package/Samples~/DI - Zenject/README.md

@@ -2,17 +2,23 @@
 
 ## Why This Integration Matters
 
-**The Problem:** When using dependency injection with Zenject, you often need to wire up both:
-1. **Dependencies** (injected via constructor/properties/fields)
-2. **Hierarchy references** (SpriteRenderer, Rigidbody2D, child colliders, etc.)
+**Stop Writing GetComponent Boilerplate in Every Single Script**
 
-Doing this manually means writing boilerplate in every component.
+When using dependency injection with Zenject, you've solved half the problem - your service dependencies get injected cleanly. But you're **still stuck** writing repetitive `GetComponent` boilerplate for hierarchy references in every. single. MonoBehaviour.
 
-**The Solution:** Unity Helpers' Zenject integration automatically wires up relational component fields **right after** DI injection completes - giving you the best of both worlds with zero extra code.
+**The Painful Reality:**
+
+1. **Dependencies** → ✅ Handled by Zenject (IHealthSystem, IAudioService, etc.)
+2. **Hierarchy references** → ❌ Still manual hell (SpriteRenderer, Rigidbody2D, child colliders, etc.)
+
+You're using a modern DI framework but still writing 2008-era Unity boilerplate. **Unity Helpers fixes this.**
+
+**The Solution:** This integration automatically wires up relational component fields **right after** DI injection completes - giving you the best of both worlds with **literally zero extra code per component**.
 
 ### ⚡ Quick Example: Before vs After
 
 **Before (Manual):**
+
 ```csharp
 public class Enemy : MonoBehaviour
 {
@@ -36,6 +42,7 @@ public class Enemy : MonoBehaviour
 ```
 
 **After (With Integration):**
+
 ```csharp
 public class Enemy : MonoBehaviour
 {
@@ -50,7 +57,9 @@ public class Enemy : MonoBehaviour
 }
 ```
 
-**Time Saved:** 10-20 lines of boilerplate per component × hundreds of components = **weeks** of development time.
+**⏱️ Time Saved:** 10-20 lines of boilerplate per component × hundreds of components = **weeks** of development time.
+**🧠 Mental Load Eliminated:** No more context-switching between DI patterns and Unity hierarchy patterns.
+**🐛 Bugs Prevented:** Automatic validation catches missing references **before** they cause runtime errors.
 
 ---
 
@@ -60,37 +69,47 @@ public class Enemy : MonoBehaviour
 
 1. Add a `SceneContext` to your scene (if you don't have one already)
 2. Add the `RelationalComponentsInstaller` component to the same GameObject
-3. *(Optional)* Toggle **"Assign Scene On Initialize"** to automatically wire all scene components after the container builds
+3. Enable **"Assign Scene On Initialize"** to automatically wire all scene components after the container builds (recommended)
 
 ![SceneContext Setup](../../Docs/Images/zenject_setup.png)
 
+> 💡 **Beginner tip:** Enable both checkboxes in the inspector:
+>
+> - ✅ **Assign Scene On Initialize** → Auto-wires all scene objects (saves you from calling it manually)
+> - ✅ **Listen For Additive Scenes** → Auto-wires newly loaded scenes (great for multi-scene setups)
+
 ### Step 2: Use With Prefab Instantiation
 
-When spawning prefabs at runtime, use `InstantiateComponentWithRelations` instead of regular Zenject instantiation:
+When spawning prefabs at runtime, use the helpers that combine instantiation, DI, and relational assignment:
 
 ```csharp
 using UnityEngine;
 using Zenject;
 using WallstopStudios.UnityHelpers.Integrations.Zenject;
 
-public class EnemySpawner : MonoBehaviour
+public sealed class EnemySpawner : MonoBehaviour
 {
     [Inject] private DiContainer _container;
     [SerializeField] private Enemy _enemyPrefab;
+    [SerializeField] private GameObject _enemySquadPrefab;
 
-    public void SpawnEnemy(Vector3 position)
+    public Enemy SpawnEnemy(Transform parent)
     {
-        // ✨ Performs DI injection AND relational component wiring
-        Enemy enemy = _container.InstantiateComponentWithRelations(
-            _enemyPrefab,
-            position,
-            Quaternion.identity,
-            parentTransform: null
+        return _container.InstantiateComponentWithRelations(_enemyPrefab, parent);
+    }
+
+    public GameObject SpawnEnemySquad(Transform parent)
+    {
+        return _container.InstantiateGameObjectWithRelations(
+            _enemySquadPrefab,
+            parent,
+            includeInactiveChildren: true
         );
+    }
 
-        // enemy._healthSystem is injected
-        // enemy._animator, enemy._rigidbody are auto-wired
-        // Ready to use immediately!
+    public void HydrateExisting(GameObject root)
+    {
+        _container.AssignRelationalHierarchy(root, includeInactiveChildren: true);
     }
 }
 ```
@@ -103,7 +122,8 @@ public class EnemySpawner : MonoBehaviour
 
 This sample provides a complete working example:
 
-- **Scripts/SpawnerZenject.cs** - Runtime instantiation using `InstantiateComponentWithRelations()`
+- **Scripts/SpawnerZenject.cs** - Demonstrates `InstantiateComponentWithRelations`, `InstantiateGameObjectWithRelations`, optional pooling, and hierarchy hydration
+- **Scripts/RelationalConsumerPool.cs** - Minimal `RelationalMemoryPool` implementation for use with Zenject memory pools
 - **Scripts/RelationalConsumer.cs** - Component demonstrating relational attributes
 - **Prefabs/RelationalConsumer.prefab** - Example prefab with relational fields
 - **Prefabs/SpawnerZenject.prefab** - Spawner prefab showing runtime usage
@@ -119,11 +139,15 @@ This sample provides a complete working example:
 
 ---
 
-## 🎯 Common Use Cases
+## 🎯 Common Use Cases (By Experience Level)
+
+### 🟢 Beginner: "I just want my components to work"
+
+**Perfect for:** Player controllers, enemy AI, simple gameplay scripts
 
-### Scene Objects with Both DI and Hierarchy References
+**What you get:** No more `GetComponent` calls, no more null reference exceptions from missing components
 
-Perfect for player controllers, managers, and gameplay systems:
+**Example:**
 
 ```csharp
 public class PlayerController : MonoBehaviour
@@ -150,56 +174,56 @@ public class PlayerController : MonoBehaviour
 
 **Important:** Enable **"Assign Scene On Initialize"** in the `RelationalComponentsInstaller` for automatic scene wiring.
 
-### Runtime-Spawned Prefabs
+### 🟡 Intermediate: "I'm spawning objects at runtime"
 
-For enemies, projectiles, and dynamic objects:
+**Perfect for:** Enemy spawners, projectile systems, object pooling
+
+**What you get:** One-line instantiation that handles DI injection + hierarchy wiring automatically
+
+**Example:**
 
 ```csharp
-public class ProjectileSpawner : MonoBehaviour
+public sealed class ProjectileSpawner : MonoBehaviour
 {
     [Inject] private DiContainer _container;
     [SerializeField] private Projectile _projectilePrefab;
 
-    public void Fire(Vector3 position, Vector3 direction)
+    public Projectile Fire(Vector3 position, Vector3 direction)
     {
-        // Both DI injection and relational component wiring happen here
-        Projectile projectile = _container.InstantiateComponentWithRelations(
-            _projectilePrefab,
-            position,
-            Quaternion.LookRotation(direction)
-        );
-
+        Projectile projectile = _container.InstantiateComponentWithRelations(_projectilePrefab);
+        projectile.transform.SetPositionAndRotation(position, Quaternion.LookRotation(direction));
         projectile.Launch(direction);
+        return projectile;
     }
 }
 ```
 
-### Complex Prefab Hierarchies
+### 🔴 Advanced: "I have complex hierarchies and custom workflows"
 
-For UI panels, vehicles, or multi-part systems:
+**Perfect for:** UI systems, vehicles with multiple parts, procedural generation, custom factories
+
+**What you get:** Full control over when and how wiring happens, with helpers for every scenario
+
+**Example - Complex Prefabs:**
 
 ```csharp
-public class VehicleFactory : MonoBehaviour
+public sealed class VehicleFactory : MonoBehaviour
 {
     [Inject] private DiContainer _container;
     [SerializeField] private GameObject _vehiclePrefab;
 
     public GameObject CreateVehicle()
     {
-        // Instantiate with DI
-        GameObject vehicle = _container.InstantiatePrefab(_vehiclePrefab);
-
-        // Wire up entire hierarchy - all nested components get relational wiring
-        _container.AssignRelationalHierarchy(vehicle, includeInactiveChildren: true);
-
-        return vehicle;
+        return _container.InstantiateGameObjectWithRelations(
+            _vehiclePrefab,
+            parent: null,
+            includeInactiveChildren: true
+        );
     }
 }
 ```
 
-### Factory Pattern with Relational Components
-
-Combine Zenject factories with relational wiring:
+**Example - Custom Factories:**
 
 ```csharp
 public class EnemyFactory : PlaceholderFactory<Enemy>
@@ -221,6 +245,81 @@ Container.BindFactory<Enemy, EnemyFactory>()
 
 ---
 
+## 💡 Real-World Impact: A Day in the Life
+
+### Without This Integration
+
+**Morning:** You start work on a new enemy type.
+
+```csharp
+public class FlyingEnemy : MonoBehaviour
+{
+    [Inject] private IHealthSystem _health;
+    [Inject] private IAudioService _audio;
+
+    private Animator _animator;
+    private Rigidbody2D _rigidbody;
+    private SpriteRenderer _sprite;
+    private Collider2D[] _hitboxes;
+    private Transform _weaponMount;
+
+    void Awake()
+    {
+        _animator = GetComponent<Animator>();
+        if (_animator == null) Debug.LogError("Missing Animator on FlyingEnemy!");
+
+        _rigidbody = GetComponent<Rigidbody2D>();
+        if (_rigidbody == null) Debug.LogError("Missing Rigidbody2D on FlyingEnemy!");
+
+        _sprite = GetComponent<SpriteRenderer>();
+        if (_sprite == null) Debug.LogError("Missing SpriteRenderer on FlyingEnemy!");
+
+        _hitboxes = GetComponentsInChildren<Collider2D>();
+        if (_hitboxes.Length == 0) Debug.LogWarning("No hitboxes found on FlyingEnemy!");
+
+        _weaponMount = transform.Find("WeaponMount");
+        if (_weaponMount == null) Debug.LogError("Missing WeaponMount on FlyingEnemy!");
+
+        // Finally, actual game logic can start...
+    }
+}
+```
+
+**10 minutes later:** You've written 20+ lines of boilerplate before writing any actual game logic.
+
+**30 minutes later:** Null reference exception in the build! You forgot to add the SpriteRenderer to the prefab.
+
+**60 minutes later:** You're manually wiring up the 8th enemy variant of the day...
+
+### With This Integration
+
+**Morning:** You start work on a new enemy type.
+
+```csharp
+public class FlyingEnemy : MonoBehaviour
+{
+    [Inject] private IHealthSystem _health;
+    [Inject] private IAudioService _audio;
+
+    [SiblingComponent] private Animator _animator;
+    [SiblingComponent] private Rigidbody2D _rigidbody;
+    [SiblingComponent] private SpriteRenderer _sprite;
+    [ChildComponent] private Collider2D[] _hitboxes;
+    [ChildComponent(NameFilter = "WeaponMount")] private Transform _weaponMount;
+
+    // Start writing game logic immediately
+    void Start() => _animator.Play("Idle");
+}
+```
+
+**2 minutes later:** You're done with wiring and writing game logic.
+
+**10 minutes later:** You've shipped 5 enemy variants with zero boilerplate.
+
+**Never:** You never see "Missing component" runtime errors because validation happens automatically with helpful messages.
+
+---
+
 ## 🔧 Advanced Configuration
 
 ### RelationalComponentsInstaller Options
@@ -228,6 +327,7 @@ Container.BindFactory<Enemy, EnemyFactory>()
 The installer component provides these settings:
 
 **Assign Scene On Initialize** *(default: true)*
+
 - When enabled, automatically wires all scene components with relational attributes after the container builds
 - Disable if you want to manually control when scene wiring happens
 
@@ -276,11 +376,68 @@ Container.BindInterfacesTo<GameBootstrap>().AsSingle();
 ```
 
 Or enable auto-prewarm on the `AttributeMetadataCache` asset:
+
 1. Create: `Assets > Create > Wallstop Studios > Unity Helpers > Attribute Metadata Cache`
 2. Enable **"Prewarm Relational On Load"** in the Inspector
 
 ---
 
+## 🧰 Additional Helpers & Recipes
+
+### One-liners for DI + Relational Wiring
+
+```csharp
+// Inject + assign a single component
+Container.InjectWithRelations(component);
+
+// Instantiate a component prefab + assign
+var comp = Container.InstantiateComponentWithRelations(prefabComp, parent);
+
+// Inject + assign a whole hierarchy
+Container.InjectGameObjectWithRelations(root, includeInactiveChildren: true);
+
+// Instantiate a GameObject prefab + inject + assign hierarchy
+var go = Container.InstantiateGameObjectWithRelations(prefabGo, parent);
+```
+
+### Additive Scenes & Options
+
+In the `RelationalComponentsInstaller`, enable “Assign Scene On Initialize” and “Listen For Additive Scenes”. You can also control scanning behavior via options:
+
+```csharp
+public sealed class GameInstaller : MonoInstaller
+{
+    public override void InstallBindings()
+    {
+        // Bind assigner (done by installer automatically if used)
+        // Container.Bind<IRelationalComponentAssigner>().To<RelationalComponentAssigner>().AsSingle();
+
+        // Configure scan options used by the initializer/listener
+        Container.BindInstance(new RelationalSceneAssignmentOptions(
+            includeInactive: true,
+            useSinglePassScan: true
+        ));
+
+        // Register initializer + additive scene listener (installer toggles also available)
+        Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
+        Container.BindInterfacesTo<RelationalSceneLoadListener>().AsSingle();
+    }
+}
+```
+
+### Pools
+
+Use DI-aware Zenject memory pools to assign on spawn automatically:
+
+```csharp
+public class EnemyPool : RelationalMemoryPool<Enemy> {}
+
+// Or with a spawn parameter
+public class BulletPool : RelationalMemoryPool<Vector3, Bullet> {}
+```
+
+---
+
 ## ❓ Troubleshooting
 
 ### My relational fields are null even with the integration
@@ -293,15 +450,15 @@ Or enable auto-prewarm on the `AttributeMetadataCache` asset:
 
 2. **Scene components not wired?**
    - Enable **"Assign Scene On Initialize"** in the `RelationalComponentsInstaller`
-   - Or manually call `_container.AssignRelationalComponents(this)` in your component
+   - Or manually call `_container.AssignRelationalHierarchy(gameObject, includeInactiveChildren: true)` at bootstrap time
 
 3. **Are you using the right attributes?**
    - Fields need `[SiblingComponent]`, `[ParentComponent]`, or `[ChildComponent]` attributes
    - These are different from `[Inject]` - you can use both on the same component
 
 4. **Runtime instantiation not working?**
-   - Use `_container.InstantiateComponentWithRelations()` instead of regular Zenject methods
-   - Regular `InstantiatePrefab()` won't trigger relational wiring
+   - Use `_container.InstantiateComponentWithRelations(...)`, `_container.InstantiateGameObjectWithRelations(...)`, or `_container.AssignRelationalHierarchy(...)`
+   - Regular `InstantiatePrefab()`/`InstantiatePrefabForComponent()` won't trigger relational wiring without these helpers
 
 5. **Check your filters:**
    - `TagFilter` must match an existing Unity tag exactly
@@ -310,14 +467,16 @@ Or enable auto-prewarm on the `AttributeMetadataCache` asset:
 ### Do I need to call AssignRelationalComponents() in Awake()?
 
 **No!** The integration handles this automatically:
+
 - **Scene objects:** Wired when you enable "Assign Scene On Initialize" (recommended)
-- **Runtime objects:** Wired when you call `InstantiateComponentWithRelations()`
+- **Runtime objects:** Wired when you call any of the helper methods (`InstantiateComponentWithRelations`, `InstantiateGameObjectWithRelations`, `AssignRelationalHierarchy`, or the pooling helpers built on `RelationalMemoryPool`)
 
 Only call `AssignRelationalComponents()` manually if you need fine-grained control.
 
 ### Does this work without Zenject?
 
 **Yes!** The integration gracefully falls back to standard Unity Helpers behavior if Zenject isn't detected. You can:
+
 - Adopt incrementally without breaking existing code
 - Use in projects that mix DI and non-DI components
 - Remove Zenject later without refactoring all your components
@@ -327,6 +486,7 @@ Only call `AssignRelationalComponents()` manually if you need fine-grained contr
 **Minimal:** Relational component assignment happens once per component at initialization time. After that, there's zero runtime overhead - the references are just regular fields.
 
 **Optimization tips:**
+
 - Use `MaxDepth` to limit hierarchy traversal
 - Use `TagFilter` or `NameFilter` to narrow searches
 - Use `OnlyDescendants`/`OnlyAncestors` to exclude self when appropriate
@@ -334,6 +494,7 @@ Only call `AssignRelationalComponents()` manually if you need fine-grained contr
 ### Zenject vs Extenject?
 
 This integration works with **all** Zenject variants:
+
 - **Zenject** (original)
 - **Extenject** (community fork)
 - **Zenject (Modesttree)** (updated original)
@@ -345,17 +506,20 @@ Unity Helpers automatically detects which one you're using.
 ## 📚 Learn More
 
 **Unity Helpers Documentation:**
-- [Relational Components Guide](../../RELATIONAL_COMPONENTS.md) - Complete attribute reference and recipes
-- [Getting Started](../../GETTING_STARTED.md) - Unity Helpers quick start guide
+
+- [Relational Components Guide](../../Docs/RELATIONAL_COMPONENTS.md) - Complete attribute reference and recipes
+- [Getting Started](../../Docs/GETTING_STARTED.md) - Unity Helpers quick start guide
 - [Main README](../../README.md) - Full feature overview
 
 **Zenject Documentation:**
+
 - [Zenject GitHub](https://github.com/modesttree/Zenject) - Official Zenject documentation
 - [Extenject GitHub](https://github.com/svermeulen/Extenject) - Community fork with updates
 
 **Troubleshooting:**
-- [Relational Components Troubleshooting](../../RELATIONAL_COMPONENTS.md#troubleshooting) - Detailed solutions
-- [DI Integration Testing Guide](../../RELATIONAL_COMPONENTS.md#di-integrations-testing-and-edge-cases) - Advanced scenarios
+
+- [Relational Components Troubleshooting](../../Docs/RELATIONAL_COMPONENTS.md#troubleshooting) - Detailed solutions
+- [DI Integration Testing Guide](../../Docs/RELATIONAL_COMPONENTS.md#di-integrations-testing-and-edge-cases) - Advanced scenarios
 
 ---
 
@@ -364,7 +528,7 @@ Unity Helpers automatically detects which one you're using.
 1. **Try the sample scene:** Open `Zenject_Sample.unity` and press Play
 2. **Read the scripts:** See how `SpawnerZenject` and `RelationalConsumer` work
 3. **Add to your project:** Add `RelationalComponentsInstaller` to your `SceneContext`
-4. **Explore attributes:** Check out the [Relational Components Guide](../../RELATIONAL_COMPONENTS.md) for all options
+4. **Explore attributes:** Check out the [Relational Components Guide](../../Docs/RELATIONAL_COMPONENTS.md) for all options
 
 ---
 
@@ -376,7 +540,7 @@ If you're choosing between Zenject and VContainer, here's how the integrations d
 |---------|---------|------------|
 | Setup | Add installer to SceneContext | Call in LifetimeScope.Configure() |
 | Scene wiring | Toggle on installer | Automatic |
-| Runtime instantiation | `InstantiateComponentWithRelations()` | `BuildUpWithRelations()` |
+| Runtime instantiation | `InstantiateComponentWithRelations()`, `InstantiateGameObjectWithRelations()`, `RelationalMemoryPool` helpers | `InstantiateComponentWithRelations()`, `InstantiateGameObjectWithRelations()`, `BuildUpWithRelations()`, `RelationalObjectPools` helpers |
 | Performance | Good | Slightly faster |
 | Maintenance | Community-maintained | Actively developed |
 
@@ -384,6 +548,7 @@ Both integrations provide the same relational component features - choose based
 
 ---
 
-**Made with ❤️ by Wallstop Studios**
+## Made with ❤️ by Wallstop Studios
 
 *Unity Helpers is production-ready and actively maintained. [Star the repo](https://github.com/wallstop/unity-helpers) if you find it useful!*
+

package/Samples~/DI - Zenject/Scripts/RelationalConsumer.cs

@@ -3,6 +3,9 @@ namespace Samples.UnityHelpers.DI.Zenject
     using UnityEngine;
     using WallstopStudios.UnityHelpers.Core.Attributes;
 
+    /// <summary>
+    /// Minimal component that demonstrates relational attributes being resolved by the Zenject integration.
+    /// </summary>
     public sealed class RelationalConsumer : MonoBehaviour
     {
         [SiblingComponent]

package/Samples~/DI - Zenject/Scripts/RelationalConsumerPool.cs

@@ -0,0 +1,37 @@
+namespace Samples.UnityHelpers.DI.Zenject
+{
+    using global::Zenject;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Integrations.Zenject;
+
+    /// <summary>
+    /// Example Zenject memory pool that automatically hydrates relational fields when items are spawned.
+    /// Bind this pool in an installer with
+    /// <code>
+    /// Container.BindMemoryPool&lt;RelationalConsumer, RelationalConsumerPool&gt;()
+    ///     .FromComponentInNewPrefab(componentPrefab)
+    ///     .UnderTransform(poolRoot);
+    /// </code>
+    /// </summary>
+    public sealed class RelationalConsumerPool : RelationalMemoryPool<RelationalConsumer>
+    {
+        protected override void OnSpawned(RelationalConsumer item)
+        {
+            base.OnSpawned(item);
+            if (item != null)
+            {
+                item.gameObject.SetActive(true);
+            }
+        }
+
+        protected override void OnDespawned(RelationalConsumer item)
+        {
+            if (item != null)
+            {
+                item.gameObject.SetActive(false);
+            }
+
+            base.OnDespawned(item);
+        }
+    }
+}

package/Samples~/DI - Zenject/Scripts/RelationalConsumerPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f5f3d2a1c3e941dca246b1a20f7c9d1b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+