Unity-利用特性反射来绑定 UI

using System;

public class DoubleUIProp
{
    public double _value;

    private double val
    {
        get { return _value; }
        set
        {
            _value = value;
            InvokeUI();
        }
    }

    private Action<double> _onValueChange = null;
    private Func<double> _onUIChange = null;

    public DoubleUIProp()
    {
    }

    public DoubleUIProp(double value)
    {
        _value = value;
    }

    public void Set(double value)
    {
        this.val = value;
    }

    public double Get()
    {
        InvokeValue();
        return this.val;
    }

    public void InvokeValue()
    {
        if (_onUIChange != null)
        {
            _value = _onUIChange.Invoke();
        }
    }

    public void InvokeUI()
    {
        _onValueChange?.Invoke(val);
    }

    public override string ToString()
    {
        return val.ToString();
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UIListProp<T>
{
    private List<T> _value;

    private List<T> val
    {
        get
        {
            return _value;
        }
        set
        {
            _value = value;
            Invoke();
        }
    }

    public int Count { get; set; }

    private Action<int> _onValueChange = null;

    public UIListProp() { }

    public UIListProp(List<T> value)
    {
        //this.val = value;
        _value = value;
    }

    public List<T> Get()
    {
        return val;
    }

    public void Set(List<T> value)
    {
        val = value;
        Count = val.Count;
    }

    public void Invoke()
    {
        if (val != null)
        {
            _onValueChange?.Invoke(val.Count);
        }
    }

    public override string ToString()
    {
        string res = "[";
        foreach (var item in val)
        {
            res += item.ToString() + ",";
        }

        res += "]";
        return res;
    }
}

using System;

/// <summary>
/// 绑定UI组件和数据，使其根据数据修改UI
/// </summary>
[AttributeUsage(AttributeTargets.Property)]
public class UIDataBind : Attribute
{
    public string _type;
    public string _path;
    public UIDataBind(string type, string path)
    {
        _type = type;
        _path = path;
    }
}

using System;

/// <summary>
/// 绑定UI组件和动作事件，使其支持交互
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public class UIActionBind : Attribute
{
    public string _type;

    public string _path;

    public UIActionBind(string type,string path)
    {
        _type = type;
        _path = path;
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 绑定UI监听事件
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public class UIListenerBind : Attribute
{
    public string _name;

    public UIListenerBind(string name)
    {
        _name = name;
    }
}

using System;

[AttributeUsage(AttributeTargets.Class)]
public class UIClassBind : Attribute
{
    public UIClass type;

    public UIClassBind(UIClass type)
    {
        this.type = type;
    }
}

private void BindData(PropertyInfo prop, object attr, GComponent main)
{
    UIDataBind uiBind = (UIDataBind)attr;

    var onValueChange = prop.PropertyType.GetField("_onValueChange", _flag);
    var onUIChange = prop.PropertyType.GetField("_onUIChange", _flag);

    var value = prop.GetValue(this);
    if (value == null)
    {
        if (prop.PropertyType.Equals(typeof(UIProp)))
        {
            value = new UIProp();
        }
        else
        {
            Type genericType = typeof(UIListProp<>).MakeGenericType(prop.PropertyType.GenericTypeArguments);
            value = Activator.CreateInstance(genericType);
        }
        prop.SetValue(this, value);
    }

    switch (uiBind._type)
    {
        case "TextField":
            GTextField textField = FguiUtils.GetUI<GTextField>(main, uiBind._path);
            void ActionText(string data)
            {
                if (textField != null)
                {
                    textField.text = data;
                }
            }

            string ActionTextUI()
            {
                return textField.text;
            }

            onValueChange?.SetValue(value, (Action<string>)ActionText);
            onUIChange?.SetValue(value, (Func<string>)ActionTextUI);
            break;
        //......
    }
}

private void BindAction(MethodInfo method, object attr, GComponent main)
{
    UIActionBind uiBind = (UIActionBind)attr;
    GObject obj = FguiUtils.GetUI<GObject>(main, uiBind._path);
    switch (uiBind._type)
    {
        case "Click":
            var methondParamsClick = method.GetParameters();
            Delegate click = null;
            if (methondParamsClick.Length == 0)
            {
                click = Delegate.CreateDelegate(typeof(EventCallback0), this, method);
                obj.onClick.Set((EventCallback0)click);
            }
            else
            {
                click = Delegate.CreateDelegate(typeof(EventCallback1), this, method);
                obj.onClick.Set((EventCallback1)click);
            }
            break;
        //......
    }
}

private void BindListener(MethodInfo method, object attr, string id)
{
    UIListenerBind uiBind = (UIListenerBind)attr;
    var eventFunc = Delegate.CreateDelegate(typeof(Action<ArrayList>), this, method);
    EventManager.AddListening(id, uiBind._name, (Action<ArrayList>)eventFunc);
}

/// <summary>
/// 绑定 类
/// </summary>
/// <param name="attr"></param>
private void BindClass(object attr)
{
    UIClassBind uiClassBind = (UIClassBind)attr;

    switch (uiClassBind.type)
    {
        case UIClass.Model:
            if (_model == null)
            {
                _model = new GGraph();
                _model.displayObject.gameObject.name = id + "_" + name + "_Model";

                UIColor colorAttr = _type.GetCustomAttribute<UIColor>();
                Color color = new Color(0, 0, 0, 0);
                if (colorAttr != null)
                {
                    color = colorAttr.color;
                }

                Vector2 size = GRoot.inst.size;
                _model.DrawRect(size.x, size.y, 0, new Color(), color);
            }

            UIManager.Ins().SetModel(uiNode, _model);

            _model.onClick.Set(() =>
            {
                if (uiClassBind.extra.Length > 0 && uiClassBind.extra[0] == "Hide")
                {
                    Hide();
                    main.AddChild(_model);
                }
            });

            break;
        //其他case
    }
}

using System;
using UnityEngine;

public class UITween
{
    public int id;

    public float duration;

    private int _time;

    public bool isStop;

    public Action<float> updater;

    public Action callback;

    public void Update(int delta)
    {
        _time += delta;
        if (_time <= duration)
        {
            updater?.Invoke(_time);
        }
        else
        {
            updater?.Invoke(duration);
            callback?.Invoke();
            isStop = true;
            updater = null;
            callback = null;
        }
    }
}

using System.Collections.Generic;
using UnityEngine;

public class TweenUpdater : MonoBehaviour
{
    private Dictionary<int,UITween> _actions = new Dictionary<int,UITween>();

    private List<int> _removeActionIndexes = new List<int>();

    void Update()
    {
        int delta = (int)(Time.deltaTime * 1000);
        foreach (var action in _actions)
        {
            UITween vt = action.Value;

            if (vt.isStop)
            {
                _removeActionIndexes.Add(vt.id);
            }
            else
            {
                vt.Update(delta);
            }
        }

        for (int i = _removeActionIndexes.Count - 1; i >= 0; i--)
        {
            _actions.Remove(_removeActionIndexes[i]);
            _removeActionIndexes.RemoveAt(i);
        }
    }

    public void AddTween(UITween tween)
    {
        _actions.Add(tween.id,tween);
    }

    public void StopTween(int id)
    {
        UITween tween;
        _actions.TryGetValue(id, out tween);

        if (tween != null)
        {
            tween.isStop = true;
        }
    }
}

using System;
using FairyGUI;
using UnityEngine;

public class UITweenManager : Singleton<UITweenManager>
{
    private TweenUpdater _updater;

    private int _id = 0;

    public void Init()
    {
        GameObject obj = new GameObject();
        obj.name = "TweenUpdater";
        _updater = obj.AddComponent<TweenUpdater>();
    }

    public int AddTween(GObject obj, TweenTarget target, float end, int duration,
        TweenEaseType ease = TweenEaseType.Linear, Action callback = null)
    {
        UITween vt = new UITween();
        vt.id = _id++;
        vt.duration = duration;
        vt.updater = GenerateUpdater(obj, target, end, duration, ease);
        vt.callback = callback;

        _updater.AddTween(vt);

        return vt.id;
    }

    public int AddTween(GObject obj, TweenTarget target, Vector2 end, int duration,
        TweenEaseType ease = TweenEaseType.Linear, Action callback = null)
    {
        UITween vt = new UITween();
        vt.id = _id++;
        vt.duration = duration;
        vt.updater = GenerateUpdater(obj, target, end, duration, ease);
        vt.callback = callback;

        _updater.AddTween(vt);
        return vt.id;
    }

    public void StopTween(int id)
    {
        _updater.StopTween(id);
    }

    private Action<float> GenerateUpdater(GObject obj, TweenTarget target, float end, float duration,
        TweenEaseType ease)
    {
        float origin = 0;
        switch (target)
        {
            case TweenTarget.X:
                origin = obj.x;
                break;
            case TweenTarget.Y:
                origin = obj.y;
                break;
            case TweenTarget.ScaleX:
                origin =  obj.scaleX;
                break;
            case TweenTarget.ScaleY:
                origin =  obj.scaleY;
                break;
            case TweenTarget.Rotation:
                origin =  obj.rotation;
                break;
            case TweenTarget.Alpha:
                origin =  obj.alpha;
                break;
            case TweenTarget.Heihgt:
                origin =  obj.height;
                break;
            case TweenTarget.Width:
                origin =  obj.width;
                break;
        }

        void Action(float time)
        {

            float ratio = EaseUtil.Evaluate(ease, time, duration, 1.7f, 0);
            switch (target)
            {
                case TweenTarget.X:
                    obj.x = origin + ratio * end;
                    break;
                case TweenTarget.Y:
                    obj.y = origin + ratio * end;
                    break;
                case TweenTarget.ScaleX:
                    obj.scaleX = origin + ratio * end;
                    break;
                case TweenTarget.ScaleY:
                    obj.scaleY = origin + ratio * end;
                    break;
                case TweenTarget.Rotation:
                    obj.rotation = origin + ratio * end;
                    break;
                case TweenTarget.Alpha:
                    obj.alpha = origin + ratio * end;
                    break;
                case TweenTarget.Heihgt:
                    obj.height = origin + ratio * end;
                    break;
                case TweenTarget.Width:
                    obj.width = origin + ratio * end;
                    break;
            }
        }

        return Action;
    }

    private Action<float> GenerateUpdater(GObject obj, TweenTarget target, Vector2 end, float duration,
        TweenEaseType ease)
    {
        Vector2 origin = Vector2.zero;
        switch (target)
        {
            case TweenTarget.Position:
                origin = obj.xy;
                break;
            case TweenTarget.Scale:
                origin = obj.scale;
                break;
            case TweenTarget.Size:
                origin = obj.size;
                break;
        }

        void Action(float time)
        {
            float ratio = EaseUtil.Evaluate(ease, time, duration, 1.7f, 0);
            switch (target)
            {
                case TweenTarget.Position:
                    obj.xy = origin + ratio * end;
                    break;
                case TweenTarget.Scale:
                    obj.scale = origin + ratio * end;
                    break;
                case TweenTarget.Size:
                    obj.size = origin + ratio * end;
                    break;
            }
        }

        return Action;
    }
}

using System;
using System.Collections.Generic;
using FairyGUI;

public class UIManager : Singleton<UIManager>
{
    private UINode _root = new UINode();

    private int _id = 0;

    private List<GComponent> _layer = new List<GComponent>();

    private Dictionary<string, UINode> _savedView = new Dictionary<string, UINode>();

    /// <summary>
    /// 展示已存在的UI
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public UINode ShowUI(string name)
    {
        if (_savedView.TryGetValue(name, out var node))
        {
            node.ui.Show();
            return node;
        }

        Debug.Log("UI未创建");
        return null;
    }

    /// <summary>
    /// 展示UI
    /// </summary>
    /// <param name="folder"></param>
    /// <param name="package"></param>
    /// <param name="name"></param>
    /// <param name="parent"></param>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    public UINode ShowUI<T>(string folder, string package, string name, UINode parent = null)
        where T : BaseView, new()
    {
        //有保存的UI直接展示并返回
        if (_savedView.TryGetValue(name, out var node))
        {
            node.ui.Show();
            return node;
        }

        //创建没保存的UI
        Type type = typeof(T);
        //包加载逻辑暂时加载Resources文件夹内文件 如有需要可自行修改
        string packagePath = folder + "/" + package;
        UIPackage.AddPackage(packagePath);
        //创建UI
        T view = new T();
        view.id = "ui_" + _id++;
        view.name = name;
        view.main = UIPackage.CreateObject(package, type.Name).asCom;

        //创建UI节点
        UINode ui = new UINode();
        ui.ui = view;

        if (parent != null)
        {
            int layerIndex = parent.layer + 1;
            if (_layer.Count - 1 == parent.layer)
            {
                GComponent layer = new GComponent();
                layer.displayObject.gameObject.name = "Layer_" + layerIndex;
                GRoot.inst.AddChild(layer);
                _layer.Add(layer);
            }

            _layer[layerIndex].AddChild(view.main);

            parent.children.Add(view.id, ui);
            ui.parent = parent;
            ui.layer = layerIndex;
        }
        else
        {
            if (_layer.Count == 0)
            {
                GComponent layer = new GComponent();
                layer.displayObject.gameObject.name = "Layer_0";
                GRoot.inst.AddChild(layer);
                _layer.Add(layer);
            }

            _layer[0].AddChild(view.main);

            _root.children.Add(view.id, ui);
            ui.parent = _root;
            ui.layer = 0;
        }

        view.uiNode = ui;

        view.InitConfig();
        view.OnAwake();
        view.Show();

        return ui;
    }

    /// <summary>
    /// 隐藏UI
    /// </summary>
    /// <param name="ui"></param>
    public void HideUI(UINode ui)
    {
        foreach (var child in ui.children)
        {
            UINode uiChild = child.Value;
            HideUI(uiChild);
        }

        ui.ui.Hide();
    }

    /// <summary>
    /// 根据名字获取UI
    /// </summary>
    /// <param name="name"></param>
    /// <param name="parent"></param>
    /// <returns></returns>
    public UINode GetUI(string name, UINode parent = null)
    {
        if (parent == null)
        {
            parent = _root;
        }

        if (parent.ui != null && name == parent.ui.name)
        {
            return parent;
        }

        UINode node;

        foreach (var child in parent.children)
        {
            node = GetUI(name, child.Value);
            if (node != null)
            {
                return node;
            }
        }

        return null;
    }

    /// <summary>
    /// 销毁UI
    /// </summary>
    /// <param name="ui"></param>
    public void DisposeUI(UINode ui)
    {
        foreach (var child in ui.children)
        {
            UINode uiChild = child.Value;
            DisposeUI(uiChild);
        }

        //移除保存的节点
        _savedView.Remove(ui.ui.name);
        ui.children = null;
        ui.parent = null;
        ui.ui.Dispose();
    }

    /// <summary>
    /// 重新置于上层
    /// </summary>
    /// <param name="ui"></param>
    public void ResetTop(UINode ui)
    {
        _layer[ui.layer].AddChild(ui.ui.main);
    }

    /// <summary>
    /// 设置模态背景
    /// </summary>
    /// <param name="ui"></param>
    /// <param name="model"></param>
    public void SetModel(UINode ui, GGraph model)
    {
        GComponent layer = _layer[ui.layer];
        int index = layer.GetChildIndex(ui.ui.main);
        layer.AddChildAt(model, index);
    }

    /// <summary>
    /// 保存节点 需要ui名称唯一
    /// </summary>
    /// <param name="name"></param>
    /// <param name="ui"></param>
    public void SaveNode(string name, UINode ui)
    {
        _savedView[name] = ui;
    }
}