Unity-Zenject入门

01.Zenject框架简介

02.在Unity中安装Zenject

1.新建脚本DataBinder.cs

using UnityEngine;
using Zenject;

public class DataBinder : MonoInstaller
{
    public override void InstallBindings()
    {
        //项目运行时会首先执行，Zenject把Data01作为单例类(只是Zenject中的单例)
        Container.Bind<Data01>().AsSingle();
    }
}
public class Data01
{
    public void LogData(string inData)
    {
        Debug.Log(inData);
    }
}

using UnityEngine;
using Zenject;


public class ZenjectTest01:MonoBehaviour
{
    //项目运行时Zenject根据‘Inject’特征为其赋值，data01为Installer中Data01的单例实体。
    [Inject]private Data01 data01;
    private void Awake()
    {
        if(data01 != null)
        {
            data01.LogData("Hello zenject");
        }
    }
}

3.返回Unity编辑器在Hierarchy窗口中右键创建Zenject->Scene Context,挂载‘DataBinder’到该游戏物体。为Scene Context指定MonoInstallers。

4.新建一个空物体，然后挂载‘ZenjectTest01’到该物体。

public class Foo
{
    IBar _bar;

    public Foo(IBar bar)
    {
        _bar = bar;
    }
}

2.成员变量注入

public class Foo
{
    [Inject]
    IBar _bar;
}

3.属性注入

属性注入的工作方式与字段注入相同，但应用于 C# 属性。就像字段一样，在这种情况下，set可以是私有的，也可以是公共的。

public class Foo
{
    [Inject]
    public IBar Bar
    {
        get;
        private set;
    }
}

4.方法注入

public class Foo
{
    IBar _bar;
    Qux _qux;

    [Inject]
    public void Init(IBar bar, Qux qux)
    {
        _bar = bar;
        _qux = qux;
    }
}

using zenject.bind;
using Zenject;

namespace zenject.installer
{
    public class ZenjectInstaller : MonoInstaller<ZenjectInstaller>
    {
        public override void InstallBindings()
        {
            Container.Bind<ZenjectBind>().AsSingle();
            Container.Bind<IBinded>().To<Binded>().AsSingle();
        }
    }
}
//MonoInstaller是继承自MonoBehaviour，由于安装器需要第一时间运行；
//一般会定义一个SceneContext存储在Unity的Scene当中，在游戏Splash的时候启动这些代码，也就是Logo显示的时候；
//重写父类里面的InstallBindings()，在这个方法里面绑定需要构建的引用的关系。

- 继承Installer，一般用来作为子安装器使用，因为安装器需要在Project Contex或者Scene Context中赋值才能执行。

using zenject.bind;
using Zenject;

namespace zenject.installer
{
    public class ZenjectInstaller : MonoInstaller<ZenjectInstaller>
    {
        public override void InstallBindings()
        {
            SubGroupInstaller.Install(Container);
        }
    }

    public class SubGroupInstaller : Installer<SubGroupInstaller>
    {
        public override void InstallBindings()
        {
            Container.Bind<ZenjectBind>().AsSingle();
            Container.Bind<IBinded>().To<Binded>().AsSingle();
        }
    }
}
//Installer一般用于引用关系复杂的时候，起到分组绑定；符合软件设计的开闭原则，由于不是Mono的继承，项目里面可以拥有多个分组Installer信息；跟MonoInstaller不一样，必须要重写父类的方法

- 继承ScriptableObjectInstaller，一般作为配置文件安装器，在Project Context中指定。ScriptableObjectInstaller需要我们先去Projec窗口中生成一个Scriptable物体，方便修改里面配置信息。

using System;
using UnityEngine;
using Zenject;

namespace zenject.installer
{
    //创建右键菜单，生成Scriptable物体
    [CreateAssetMenu(fileName = "ZenjectScriptableInstaller", menuName = "Installers/ZenjectScriptableInstaller")]
    public class ZenjectScriptableInstaller : ScriptableObjectInstaller<ZenjectScriptableInstaller>
    {
        public Player.Settings Player;

        public override void InstallBindings()
        {
            Container.BindInstances(Player);
        }
    }

    public class Player : ITickable
    {
        readonly Settings _settings;
        Vector3 _position;

        public Player(Settings settings)
        {
            _settings = settings;
        }

        public void Tick()
        {
            _position += Vector3.forward * _settings.Speed;
        }

        [Serializable]
        public class Settings
        {
            public float Speed;
        }
    }
}

3. 安装器按照使用位置分类 Scene Installer和Project Installer

- Scene Installer在Scene Context中指定。只能在当前场景中有效，一个场景中可以有多个Scene Install。

- Project Installer在Project Context中指定。在所有场景中有效。

如果要使用自定义Project Installer，可以在Resources文件夹中创建一个‘ProjectContext’的预制体，预制体上挂载我们需要在整个项目中使用的Installer。

4. Container容器，容器是Zenject存放被注入类的地方。

//要绑定的类
public class Foo
{
    IBar _bar;

    public Foo(IBar bar)
    {
        _bar = bar;
    }
}

Container.Bind<Foo>().AsSingle();
Container.Bind<IBar>().To<Bar>().AsSingle();

Container.Bind<Foo>();
Container.Bind<Foo>().FromNew();

Container.Bind<Foo>().FromInstance(new Foo());

// You can also use this short hand which just takes ContractType from the parameter type
Container.BindInstance(new Foo());

// This is also what you would typically use for primitive types
Container.BindInstance(5.13f);
Container.BindInstance("foo");

// Or, if you have many instances, you can use BindInstances
Container.BindInstances(5.13f, "foo", new Foo());

Container.Bind<Foo>().FromMethod(SomeMethod);

Foo SomeMethod(InjectContext context)
{
    ...
    return new Foo();
}

Container.Bind<Foo>().FromMethodMultiple(GetFoos);

IEnumerable<Foo> GetFoos(InjectContext context)
{
    ...
    return new Foo[]
    {
        new Foo(),
        new Foo(),
        new Foo(),
    }
}