Unity и Zenject(Extenject)

using Zenject;
public class BootstrapInstaller: MonoInstaller
{
    public override void InstallBindings()
    {
        
    }
}

public class HeroController : MonoBehaviour
{
    public void ChangeLocalScale()
    {
        gameObject.transform.localScale = new Vector3(2, 2, 2);
    }
}

using Zenject;
public class LocationInstaller : MonoInstaller
{
    public Transform StartPoint;
    public GameObject HeroPrefab;
    public override void InstallBindings()
    {
        HeroController heroController = Container
            .InstantiatePrefabForComponent<HeroController>(HeroPrefab, StartPoint.position, Quaternion.identity, null);
    }

Container.Bind<ContractType>()
    .WithId(Identifier)
    .To<ResultType>()
    .FromConstructionMethod()
    .AsScope()
    .WithArguments(Arguments)
    .OnInstantiated(InstantiatedCallback)
    .When(Condition)
    .(Copy|Move)Into(All|Direct)SubContainers()
    .NonLazy()
    .IfNotBound();

using UnityEngine;
using Zenject;
namespace Infrastructure
{
    public class LocationInstaller : MonoInstaller
    {
        public GameObject HeroPrefab;

        public override void InstallBindings()
        {
            HeroController heroController = Container
                .InstantiatePrefabForComponent<HeroController>(HeroPrefab,
                    StartPoint.position, Quaternion.identity,
                    null);

            Container
                .Bind<HeroController>()
                .FromInstance(heroController)
                .AsSingle();
        }
    }
}

using UnityEngine;
using Zenject;

public class EnemyController : MonoBehaviour
{
    [Inject]
    private void Construct(HeroController heroController)
    {
        heroController.ChangeLocalScale();
    }
} 

using UnityEngine;
using TMPro;
public class InventoryDisplay : MonoBehaviour
{
    public TMP_Text[] HotbarSlots;
}

 public InventoryDisplay inventoryDisplay;

            Container
                .Bind<InventoryDisplay>()
                .FromInstance(inventoryDisplay)
                .AsSingle();

using UnityEngine;
using Zenject;
namespace Infrastructure
{
    public class LocationInstaller : MonoInstaller
    {
        public Transform StartPoint;
        public GameObject HeroPrefab;

        public InventoryDisplay inventoryDisplay;

        public override void InstallBindings()
        {
            BindInventoryDisplay();
            BindHero();
        }

        private void BindInventoryDisplay()
        {
            Container
                .Bind<InventoryDisplay>()
                .FromInstance(inventoryDisplay)
                .AsSingle();
        }

        private void BindHero()
        {
            HeroController heroController = Container
                .InstantiatePrefabForComponent<HeroController>(HeroPrefab, StartPoint.position, Quaternion.identity,
                    null);

            Container
                .Bind<HeroController>()
                .FromInstance(heroController)
                .AsSingle();
        }
    }
}

using Zenject;
using UnityEngine;
using UnityEngine.UI;
using TMPro;

namespace Infrastructure
{
    public class CharacterInventory : MonoBehaviour
    {
        TMP_Text[] HotbarDisplayHolders = new TMP_Text[3];

        [Inject]
        public void Construct(InventoryDisplay inventoryDisplay)
        {
            HotbarDisplayHolders = inventoryDisplay.HotbarSlots;
        }

        void Start()
        {
            HotbarDisplayHolders[1].text = "герой изменил текст";
        }

    }
}

using System;

public interface IInputService
{
    event Action ClickOne;
    event Action ClickTwo;
}

using System;
using System.Linq;
using UnityEngine;
using UnityEngine.LowLevel;
public class KeyboardInput : IInputServiсe, ITickable
{
    public event Action ClickOne;
    public event Action ClickTwo;

    public void Tick()
    {
        if (Input.GetKey(KeyCode.A))
        {
            ClickOne?.Invoke();
        }
        if (Input.GetKey(KeyCode.B))
        {
            ClickTwo?.Invoke();
        }
    }
}

using Zenject;
public class BootstrapInstaller : MonoInstaller
{
    KeyboardInput keyboardInput;
    public override void InstallBindings()
    {
        keyboardInput = new KeyboardInput();

        Container
            .Bind<IInputServiсe>()
            .FromInstance(keyboardInput)
            .AsSingle()
            .NonLazy();
            
        Container
            .Bind<ITickable>()
            .FromInstance(keyboardInput)
            .AsSingle()
            .NonLazy();
    }
}

using UnityEngine;
using Zenject;
public class HeroController : MonoBehaviour
{
    IInputServiсe _inputServiсe;

    [Inject]
    public void Construct(IInputServiсe inputServiсe)
    {
        _inputServiсe = inputServiсe;
        _inputServiсe.ClickOne += ClickOne;
        _inputServiсe.ClickTwo += ClickTwo;
    }

    private void ClickOne()
    {
        gameObject.transform.localScale = new Vector3(1, 1, 1);
    }

    private void ClickTwo() 
    { 
        gameObject.transform.localScale = new Vector3(3, 3, 3); 
    }


    public void ChangeLocalScale()
    {
        gameObject.transform.localScale = new Vector3(2, 2, 2);
    }

    void OnDestroy()
    {
        _inputServiсe.ClickOne -= ClickOne;
        _inputServiсe.ClickTwo -= ClickTwo;
    }
}

public enum EnemyType
{
    Melee = 0,
    ranged = 1
}

using UnityEngine;

public class EnemyMarker : MonoBehaviour
{
    public EnemyType enemyType;
    private void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawSphere(transform.position, 1);
        Gizmos.color = Color.white;
    }
}

using UnityEngine;

public interface IEnemyFactory
{
    void Create(EnemyType enemyType, Vector3 at);
    void Load();
}


public class EnemyFactory : IEnemyFactory
{
    public Object _meleeEnemyPrefab;
    public Object _rangeEnemyPrefab;

    public EnemyFactory(DiContainer diContainer)
    {
        _diContainer = diContainer;
    }

    public void Load() {}
    public void Create(EnemyType enemyType, Vector3 at) { }
}

 Container.Bind<IEnemyFactory>().To<EnemyFactory>().AsSingle();

  public void Initialize()
    {
        // DiContainer.Resolve — возвращает экземпляр, соответствующий заданному типу
        // этот кодвыполнится так как в конструкторе забиндили фабрику
        var enemyFactory = Container.Resolve<IEnemyFactory>();
        enemyFactory.Load();

        foreach (EnemyMarker marker in EnemyMarkers)
        {
            enemyFactory.Create(marker.enemyType, marker.transform.position);
        }
    }

 Container.BindInterfacesTo<LocationInstaller>().FromInstance(this).AsSingle();

 public void Load()
    {
        _meleeEnemyPrefab = Resources.Load(PathEnemyMelee);
        _rangeEnemyPrefab = Resources.Load(PathEnemyRange);
    }

  public EnemyFactory(DiContainer diContainer)
    {
        _diContainer = diContainer;
    }

public void Create(EnemyType enemyType, Vector3 at)
    {
        switch (enemyType)
        {
            case EnemyType.Melee:
                _diContainer.InstantiatePrefab(_meleeEnemyPrefab, at, Quaternion.identity, null);
                break;
            case EnemyType.Ranged:
                _diContainer.InstantiatePrefab(_rangeEnemyPrefab, at, Quaternion.identity, null);
                break;
        }

    }

using UnityEngine;
using Zenject;

public class EnemyFactory : IEnemyFactory
{
    private const string PathEnemyMelee = "EnemyMelee";
    private const string PathEnemyRange = "EnemyRange";
    private readonly DiContainer _diContainer;
    public Object _meleeEnemyPrefab;
    public Object _rangeEnemyPrefab;

    public EnemyFactory(DiContainer diContainer)
    {
        _diContainer = diContainer;
    }

    public void Load()
    {
        _meleeEnemyPrefab = Resources.Load(PathEnemyMelee);
        _rangeEnemyPrefab = Resources.Load(PathEnemyRange);

    }
    public void Create(EnemyType enemyType, Vector3 at)
    {
        switch (enemyType)
        {
            case EnemyType.Melee:
                _diContainer.InstantiatePrefab(_meleeEnemyPrefab, at, Quaternion.identity, null);
                break;
            case EnemyType.Ranged:
                _diContainer.InstantiatePrefab(_rangeEnemyPrefab, at, Quaternion.identity, null);
                break;
        }

    }
}

using UnityEngine;
using Zenject;
public class LocationInstaller : MonoInstaller, IInitializable
{
    public Transform StartPoint;
    public GameObject HeroPrefab;
    public EnemyMarker[] EnemyMarkers;

    public InventoryDisplay inventoryDisplay;

    public override void InstallBindings()
    {
        BindInstallerInterfaces(); // LocationInstaller биндит сам себя
        BindInventoryDisplay();
        BindHero();
        BindEmenyFactory();
    }

    private void BindEmenyFactory()
    {
        Container
            .Bind<IEnemyFactory>()
            .To<EnemyFactory>()
            .AsSingle();
    }

    private void BindInstallerInterfaces()
    {
        Container.BindInterfacesTo<LocationInstaller>().FromInstance(this).AsSingle();
    }

    private void BindInventoryDisplay()
    {
        Container
            .Bind<InventoryDisplay>()
            .FromInstance(inventoryDisplay)
            .AsSingle();
    }

    private void BindHero()
    {
        HeroController heroController = Container
            .InstantiatePrefabForComponent<HeroController>(HeroPrefab, StartPoint.position, Quaternion.identity,
                null);

        Container
            .Bind<HeroController>()
            .FromInstance(heroController)
            .AsSingle();
    }
    // инициализацию объекта вне конструктора можем делать тут, удобно для фабрик и биндинга после резолва
    public void Initialize()
    {
        // DiContainer.Resolve — возвращает экземпляр, соответствующий заданному типу
        // этот кодвыполнится так как в конструкторе забиндили фабрику
        var enemyFactory = Container.Resolve<IEnemyFactory>();
        enemyFactory.Load();

        foreach (EnemyMarker marker in EnemyMarkers)
        {
            enemyFactory.Create(marker.enemyType, marker.transform.position);
        }
    }
}

public override void InstallBindings()
{
    // Создавать новый экземпляр Foo для каждого класса, который его запрашивает
    Container.Bind<Foo>().AsTransient();

    // Создавать новый экземпляр Foo для каждого класса, который запрашивает IFoo
    Container.Bind<IFoo>().To<Foo>().AsTransient();

    // Негeneric-версия приведённого выше
    Container.Bind(typeof(IFoo)).To(typeof(Foo)).AsTransient();

    ///////////// AsSingle

    // Создать один общий экземпляр Foo и переиспользовать его для всех классов, которые его запрашивают
    Container.Bind<Foo>().AsSingle();

    // Создать один общий экземпляр Foo и переиспользовать его для всех классов, которые запрашивают IFoo
    Container.Bind<IFoo>().To<Foo>().AsSingle();

    // Привязать один и тот же экземпляр к нескольким типам
    // В этом примере один и тот же экземпляр Foo будет использоваться для всех трёх типов
    // (для связывания с несколькими типами нужно использовать негeneric-версию Bind)
    Container.Bind(typeof(Foo), typeof(IFoo), typeof(IFoo2)).To<Foo>().AsSingle();

    ///////////// BindInterfaces

    // Это будет иметь тот же эффект, что и строка выше
    // Привязать все интерфейсы, которые реализует Foo, а также сам Foo к одному синглтону типа Foo
    Container.BindInterfacesAndSelfTo<Foo>().AsSingle();

    // Привязать только интерфейсы, которые реализует Foo, к экземпляру Foo
    // Полезно, если не хотите, чтобы другие классы напрямую ссылались на конкретный тип
    Container.BindInterfacesTo<Foo>().AsSingle();

    ///////////// FromInstance

    // Использовать переданный экземпляр везде, где запрашивается Foo
    // Заметьте, что в данном случае особого смысла в FromInstance нет
    Container.Bind<Foo>().FromInstance(new Foo());

    // Это просто сокращённый вариант предыдущей привязки
    // Немного удобнее, так как тип определяется из переданного объекта
    Container.BindInstance(new Foo());

    // Привязать сразу несколько экземпляров
    Container.BindInstances(new Foo(), new Bar());

    ///////////// Привязка примитивных типов

    // BindInstance чаще используется с примитивными типами
    // Использовать число 10 каждый раз, когда запрашивается int
    Container.Bind<int>().FromInstance(10);
    Container.Bind<bool>().FromInstance(false);

    // Эквивалентная запись:
    Container.BindInstance(10);
    Container.BindInstance(false);

    // Но обычно так делать не стоит — почти всегда лучше использовать условие When для примитивных значений
    Container.BindInstance(10).WhenInjectedInto<Foo>();

    ///////////// FromMethod

    // Создавать экземпляр Foo при запросе, используя указанную функцию
    // Для более сложных сценариев лучше использовать фабрику (FromFactory)
    Container.Bind<Foo>().FromMethod(GetFoo);

    // Случайным образом возвращать одну из нескольких реализаций IFoo
    // Используем Instantiate вместо new, чтобы Foo1 получил свои зависимости через инъекцию
    Container.Bind<IFoo>().FromMethod(GetRandomFoo);

    // Можно также использовать анонимный делегат напрямую
    Container.Bind<Foo>().FromMethod(ctx => new Foo());

    // Это эквивалентно AsTransient
    Container.Bind<Foo>().FromMethod(ctx => ctx.Container.Instantiate<Foo>());

    InstallMore();
}

void InstallMore()
{
    ///////////// FromResolveGetter

    // Привязать к свойству другого зависимого объекта
    // Это помогает уменьшить связанность между классами
    Container.Bind<Foo>().AsSingle();

    Container.Bind<Bar>().FromResolveGetter<Foo>(foo => foo.GetBar());

    // Другой пример с возвращением значений
    Container.Bind<string>().FromResolveGetter<Foo>(foo => foo.GetTitle());

    ///////////// FromNewComponentOnNewGameObject

    // Создать новый GameObject в корне сцены и добавить к нему MonoBehaviour Foo
    Container.Bind<Foo>().FromNewComponentOnNewGameObject().AsSingle();

    // Можно указать имя создаваемого объекта с помощью WithGameObjectName
    Container.Bind<Foo>().FromNewComponentOnNewGameObject().WithGameObjectName("Foo1").AsSingle();

    // Привязать к интерфейсу вместо конкретного класса
    Container.Bind<IFoo>().To<Foo>().FromNewComponentOnNewGameObject().AsSingle();

    ///////////// FromComponentInNewPrefab (singleton)

    // Создать новый GameObject в корне сцены, используя данный префаб
    // После того как Zenject создаст объект из префаба, он найдёт в нём компонент Foo и вернёт его
    GameObject prefab = null;
    Container.Bind<Foo>().FromComponentInNewPrefab(prefab).AsSingle();

    // Привязать к интерфейсу вместо конкретного класса
    Container.Bind<IFoo>().To<Foo>().FromComponentInNewPrefab(prefab).AsSingle();

    // Можно добавить несколько компонентов
    // Важно: будет создан только один экземпляр указанного префаба
    // Для этого на префабе должны быть компоненты Foo и Bar
    Container.Bind(typeof(Foo), typeof(Bar)).FromComponentInNewPrefab(prefab).AsSingle();

    ///////////// FromComponentInNewPrefab (Transient)

    // Создавать новый экземпляр префаба каждый раз, когда нужен Foo
    Container.Bind<Foo>().FromComponentInNewPrefab(prefab).AsTransient();

    // Привязать к интерфейсу вместо конкретного класса
    Container.Bind<IFoo>().To<Foo>().FromComponentInNewPrefab(prefab);

    ///////////// Идентификаторы

    // Привязать глобально доступную строку с именем "PlayerName"
    // Хотя часто лучше создать отдельный объект настроек и привязать его
    Container.Bind<string>().WithId("PlayerName").FromInstance("имя игрока");

    // Эквивалент предыдущей строки, но читается понятнее
    Container.BindInstance("имя игрока").WithId("PlayerName");

    // С помощью ID можно привязать несколько экземпляров одного типа:
    Container.BindInstance("foo").WithId("FooA");
    Container.BindInstance("asdf").WithId("FooB");

    InstallMore2();
}

// При внедрении зависимостей нужно использовать тот же ID:
public class Norf
{
    [Inject(Id = "FooA")]
    string _foo;
}

public class Qux
{
    [Inject(Id = "FooB")]
    string _foo;
}

public void InstallMore2()
{
    ///////////// AsCached

    // Здесь мы привязываем три экземпляра Foo, включая один без ID
    // Используем AsCached, потому что Foo не singleton, но и новый экземпляр при каждом запросе нам не нужен
    // В итоге будет создано максимум 3 экземпляра Foo
    Container.Bind<Foo>().AsCached();
    Container.Bind<Foo>().WithId("FooA").AsCached();
    Container.Bind<Foo>().WithId("FooA").AsCached();

    InstallMore3();
}

// Если ID не указан в [Inject], используется первый подходящий экземпляр
// Привязки без ID могут использоваться как значение по умолчанию, а ID — для конкретных версий
public class Norf2
{
    [Inject]
    Foo _foo;
}

// Qux2._foo будет тем же экземпляром, что и Norf2._foo
// Это возможно, потому что мы используем AsCached, а не AsTransient
public class Qux2
{
    [Inject]
    Foo _foo;

    [Inject(Id = "FooA")]
    Foo _foo2;
}

public void InstallMore3()
{
    ///////////// Conditions (условия)

    // Сделать Foo видимым только для Bar
    // Если добавить Foo в конструктор любого другого класса — он не будет найден
    Container.Bind<Foo>().AsSingle().WhenInjectedInto<Bar>();

    // Использовать разные реализации IFoo в зависимости от того, в какой класс внедряется зависимость
    Container.Bind<IFoo>().To<Foo1>().AsSingle().WhenInjectedInto<Bar>();
    Container.Bind<IFoo>().To<Foo2>().AsSingle().WhenInjectedInto<Qux>();

    // Использовать Foo1 по умолчанию, кроме случаев внедрения в Qux — там Foo2
    // Если условие совпадает, оно имеет приоритет
    Container.Bind<IFoo>().To<Foo1>().AsSingle();
    Container.Bind<IFoo>().To<Foo2>().AsSingle().WhenInjectedInto<Qux>();

    // Разрешить использовать Foo только в указанных классах
    Container.Bind<Foo>().AsSingle().WhenInjectedInto(typeof(Bar), typeof(Qux), typeof(Baz));

    // Передавать строку "my game" для всех строк, внедряемых в класс Gui с идентификатором "Title"
    Container.BindInstance("my game").WithId("Title").WhenInjectedInto<Gui>();

    // Передавать число 5 для всех int, внедряемых в класс Gui
    Container.BindInstance(5).WhenInjectedInto<Gui>();

    // Передавать 5 для всех значений float, внедряемых в параметр или поле внутри Gui с именем "width"
    // Обычно так лучше не делать, т.к. имя поля может измениться и сломать привязку
    Container.BindInstance(5.0f).When(ctx =>
        ctx.ObjectType == typeof(Gui) && ctx.MemberName == "width");

    // Создавать новый Foo для каждого класса, который создаётся как часть создания Bar
    // Например, если Bar зависит от Qux, а Qux зависит от IFoo — то для этого IFoo будет создан новый Foo
    Container.Bind<IFoo>().To<Foo>().AsTransient().When(
        ctx => ctx.AllObjectTypes.Contains(typeof(Bar)));

    ///////////// Пример сложных условий

    var foo1 = new Foo();
    var foo2 = new Foo();

    Container.Bind<Bar>().WithId("Bar1").AsCached();
    Container.Bind<Bar>().WithId("Bar2").AsCached();

    // Здесь используем ParentContexts, чтобы сопоставить несколько идентификаторов
    Container.BindInstance(foo1).When(c => c.ParentContexts.Where(x => x.MemberType == typeof(Bar) && x.Identifier == "Bar1").Any());
    Container.BindInstance(foo2).When(c => c.ParentContexts.Where(x => x.MemberType == typeof(Bar) && x.Identifier == "Bar2").Any());

    // В результате получаем:
    Assert.That(Container.ResolveId<Bar>("Bar1").Foo == foo1);
    Assert.That(Container.ResolveId<Bar>("Bar2").Foo == foo2);

    ///////////// FromResolve

    // FromResolve делает повторный поиск в контейнере
    // В результате IBar, IFoo и Foo будут ссылаться на один и тот же экземпляр Foo,
    // который, предполагается, уже есть на указанном префабе
    GameObject fooPrefab = null;
    Container.Bind<Foo>().FromComponentInNewPrefab(fooPrefab).AsSingle();
    Container.Bind<IBar>().To<Foo>().FromResolve();
    Container.Bind<IFoo>().To<IBar>().FromResolve();

    // То же самое, но короче записано
    Container.Bind(typeof(Foo), typeof(IBar), typeof(IFoo)).To<Foo>().FromComponentInNewPrefab(fooPrefab).AsSingle();

    InstallMore4();
}

void InstallMore4()
{
    ///////////// Installing Other Installers

    // Немедленно вызвать InstallBindings() у FooInstaller
    FooInstaller.Install(Container);

    // Перед вызовом FooInstaller сконфигурировать его свойство
    Container.BindInstance("foo").WhenInjectedInto<FooInstaller>();
    FooInstaller.Install(Container);

    // Аргументы можно добавить в дженерик Installer<>, чтобы сделать их строго типизированными
    FooInstallerWithArgs.Install(Container, "foo");

    ///////////// Ручное использование Container

    // Заполнить все поля/методы с [Inject] и вызвать методы с [Inject]
    var foo = new Foo();
    Container.Inject(foo);

    // Вернуть экземпляр для IFoo, используя уже добавленные привязки
    // Внутренне используется при внедрении в конструкторы
    // Если не найдёт подходящий тип — выбросит исключение
    Container.Resolve<IFoo>();

    // То же самое, но вернёт null, если не найдёт
    Container.TryResolve<IFoo>();

    // Вернуть список из 2 экземпляров Foo
    // Просто Resolve<IFoo> здесь вызовет исключение
    Container.BindInstance(new Foo());
    Container.BindInstance(new Foo());
    var foos = Container.ResolveAll<IFoo>();

    // Создать новый экземпляр Foo и внедрить зависимости в его поля/конструктор
    Container.Instantiate<Foo>();

    GameObject prefab1 = null;
    GameObject prefab2 = null;

    // Создать новый объект из префаба и внедрить зависимости в его компоненты
    GameObject go = Container.InstantiatePrefab(prefab1);

    // Создать новый объект из префаба и вернуть конкретный MonoBehaviour
    Foo foo2 = Container.InstantiatePrefabForComponent<Foo>(prefab2);

    // Добавить новый компонент к существующему GameObject
    Foo foo3 = Container.InstantiateComponent<Foo>(go);
}