UI Router в Unity + CustomEditor

public static class UIRouter
{
    private static Stack<string> _screensStack = new Stack<string>();
    private static Dictionary<string, IUIPage> _routesPageData = new Dictionary<string, IUIPage>();
    private static string _mainScreenRoute = string.Empty;

    #region const
    // Чтобы синтаксис url был единообразным, явно указываем его через константы
    // Пример ссылки:
    // canvas.Name + slash + gameObj1.Name + separator + key + equally + value + and + key2 + equally + value2 = "Canvas/Name1?key=value&key2=value2"
    public const string slash = "/";
    public const string separator = "?";
    public const string and = "&";
    public const string equally = "=";
    #endregion

    // Чтобы не выбрасовало NullReferenceException первым обращением инициализируем поля.
    public static void ForceCreate()
    {
        if (_routesPageData == null || _screensStack == null)
        {
            _routesPageData = new Dictionary<string, IUIPage>();
            _screensStack = new Stack<string>();
            _mainScreenRoute = string.Empty;
        }        
    }

    public static void SubscribePath(string path, IUIPage page)
    {
        ParseParams(path, out path);
        if (!_routesPageData.ContainsKey(path))
        {
            _routesPageData.Add(path, page);
        }
    }

    public static void UnsubscribePath(string path)
    {
        ParseParams(path, out path);
        if (_routesPageData.ContainsKey(path))
        {
            _routesPageData.Remove(path);
        }
    }

    public static void SetMainScreenRoute(string route, bool forceAdd = false)
    {
        if (_mainScreenRoute == "" || forceAdd)
        {
            _mainScreenRoute = route;
            if (_screensStack.Count == 0)
            {
                _screensStack.Push(route);
            }
        }
    }

    public static void OpenPageUrl(string route)
    {
        if (_screensStack.Count > 0)
        {
            string url = _screensStack.Peek();
            if (url.Contains(separator))
            {
                url = url.Split(separator)[0];
            }
            _screensStack.Push(_routesPageData[url].Hide());
        }
        _screensStack.Push(route);
        
        var payload = ParseParams(route, out route);
        if (_routesPageData.ContainsKey(route))
        {
            var page = _routesPageData[route];
            page.Show(payload);
        }
        else
        {
            Debug.LogError($"There no route with name: {route}");
        }
    }

    public static void ReleaseLastPage()
    {
        if (_screensStack.Count > 0)
        {
            _screensStack.Pop();
            if (_screensStack.Count >= 1)
            {
                string route = _screensStack.Peek();
                OpenPageUrl(route);
            }
            else
            {
                if (_mainScreenRoute != null) OpenPageUrl(_mainScreenRoute);
            }
        }
    
    
    public static bool CheckNameForURL(string name)
    {
        if (name.Contains(slash) || name.Contains(separator) || name.Contains(and) || name.Contains(equally))
        {
            Debug.LogError("Name must not include url syntacis chars! Error with name " + name);
            return false;
        }
        return true;
    }

    private static Dictionary<string, string> ParseParams(string fullRoute, out string route)
    {
        string routeEnd = "";
        if (fullRoute.Contains(slash))
        {
            routeEnd = fullRoute.Split(slash)[^1];
        }
        else
        {
            routeEnd = fullRoute;
        }
        var result = new Dictionary<string, string>();
        var routeParams = routeEnd.Split(separator);
        if (routeParams.Length > 1)
        {
            var parameters = routeParams[1].Split(and);
            if (parameters.Length > 0)
            {
                foreach (var param in parameters)
                {
                    var data = param.Split(equally);
                    if (data.Length > 1)
                    {
                        result[data[0]] = data[1];
                    }
                }
            }
            route = fullRoute.Split(separator)[0];
        }
        else
        {
            route = fullRoute;
        }
        return result;
    }

}

using System.Collections.Generic;
using UnityEngine;
using TMPro;
using UnityEditor;

public class PageWithTextController : MonoBehaviour, IUIPage
{
    #region Serialized Fields
    [SerializeField] private string url_ = "";
    [SerializeField] private List<TMP_Text> _Texts = new List<TMP_Text>();
    [SerializeField] private Dictionary<string, string> params_ = new Dictionary<string, string>();

    [SerializeField] public bool shouldWriteRuntimeChanges = true;
    #endregion

    #region Properties
    public string url 
    {
        get 
        {
            CreateURL(url_);
            return url_; 
        } 
    }
    public Dictionary<string, string> parametrs { get { return params_; } }
    #endregion

    #region Unity method
    private void OnDestroy()
    {
        Unsubscribe();
    }
    #endregion

    #region interface IUIPage implementation
    public void CreateURL(string url__)
    {
        if (url__.Contains(UIRouter.separator))
        {
            url__ = url__.Split(UIRouter.separator)[0];
        }
        if (shouldWriteRuntimeChanges || params_.Count == 0) { FindAndDefineChildsProperties(); }
        System.Text.StringBuilder builder = new System.Text.StringBuilder();
        builder.Append(url__);
        builder.Append(DictToString(params_));
        url_ = builder.ToString();
    }


    public void Show(Dictionary<string, string> data)
    {
        gameObject.SetActive(true);
        TryAssignProperties(data);
    }

    public string Hide()
    {
        CreateURL(url_);
        gameObject.SetActive(false);
        return url_;
    }

    public void Subscribe()
    {
        UIRouter.SubscribePath(url_, this);
    }
    public void Unsubscribe()
    {
        UIRouter.UnsubscribePath(url_);
    }
    #endregion

    /// <summary>
    /// Useful when you need to enable page through button
    /// </summary>
    public void ForceShow() { UIRouter.OpenPageUrl(url_); }


    public virtual void FindAndDefineChildsProperties()
    {
        FindAndSubscribeChildsText();
    }

    #region private methods

    protected void FindAndSubscribeChildsText()
    {
        _Texts = TextChildsCheck(gameObject);
        InitTextParametrs();
    }

    protected List<TMP_Text> TextChildsCheck(GameObject game)
    {
        if (UIRouter.CheckNameForURL(game.name))
        {
            List<TMP_Text> textList = new List<TMP_Text>(game.transform.childCount);
            List<GameObject> childs = GetAllChilds(game);
            foreach (GameObject child in childs)
            {
                TMP_Text tryText = null;
                if (child.TryGetComponent(out tryText))
                {
                    if (!textList.Contains(tryText) && UIRouter.CheckNameForURL(child.name))
                    {
                        textList.Add(tryText);
                    }
                    else
                    {
                        Debug.LogError(string.Format("All child object of IUIPage must have unique names! Not a unique name {}", child.name));
                    }
                }
                var childRes = TextChildsCheck(child);
                if (childRes != null)
                {
                    textList.AddRange(childRes);
                }
            }
            return textList;
        }
        return null;
    }

    protected void InitTextParametrs()
    {
        Dictionary<string, string> _params2 = new Dictionary<string, string>();
        foreach (TMP_Text tMP_ in _Texts)
        {
            if (tMP_ != null)
            {
                _params2.Add(tMP_.name, tMP_.text);
            }
        }
        params_ = _params2;
    }

    protected string DictToString(Dictionary<string, string> dict)
    {
        bool first = true;
        System.Text.StringBuilder builder = new System.Text.StringBuilder();
        foreach (string key in dict.Keys)
        {
            if (dict[key] != null)
            {
                if (first)
                {
                    first = false;
                    builder.AppendFormat(string.Format("{0}{1}{2}{3}", UIRouter.separator, key, UIRouter.equally, dict[key]));
                }
                else
                {
                    builder.AppendFormat(string.Format("{0}{1}{2}{3}", UIRouter.and, key, UIRouter.equally, dict[key]));
                }
            }
        }
        return builder.ToString();
    }

    protected virtual void TryAssignProperties(Dictionary<string, string> data)
    {
        foreach (TMP_Text text in _Texts)
        {
            string newText = text.text;
            if (data.TryGetValue(text.name, out newText))
            {
                text.text = newText;
                if (GUI.changed)
                {
                    EditorUtility.SetDirty(text);
                }
            }
        }
    }
    protected virtual void TryAssignProperties(string key, string value)
    {
        foreach (TMP_Text text in _Texts)
        {
            if (text.name == key)
            {
                string newText = string.Empty;
                if (params_.TryGetValue(text.name, out newText))
                {
                    text.text = newText;
                    if (GUI.changed)
                    {
                        EditorUtility.SetDirty(text);
                    }
                }
                return;
            }
        }
    }

    protected List<GameObject> GetAllChilds(GameObject game)
    {
        int children = game.transform.childCount;
        List<GameObject> childs = new List<GameObject>();
        for (int i = 0; i < children; ++i)
        {
            childs.Add(game.transform.GetChild(i).gameObject);
        }
        return childs;
    }
    #endregion
}

Многие методы указаны с модификаторами доступа protected и virtual, поэтому относительно легко можно унаследоваться от этого класса и расширить функционал, например, добавив возможность передавать цвет спрайтам.

public class CanvasManager : MonoBehaviour
{
    [SerializeField] private PageWithTextController mainPage;

    private List<IUIPage> uIPages = new List<IUIPage>();
    private static Dictionary<IUIPage, string> pagePathes = new Dictionary<IUIPage, string>();

    // Start is called before the first frame update
    private void Start()
    {
        UIRouter.ForceCreate();
        InitAllPages();
    }

    private void OnDestroy()
    {
        UnSubscribe();
    }

    public void InitAllPages()
    {
        List<IUIPage> allPagesInChilds = FindAllPagesInChilds(gameObject, gameObject.name);
        if (allPagesInChilds != null) { uIPages.AddRange(allPagesInChilds); }
        SubscribePages();
    }

    /// <summary>
    /// Чтобы не хардкодить адресс страниц, можно обращаться через этот метод и получать ссылки
    /// </summary>
    public static string GetLink(IUIPage page)
    {
        if (pagePathes.ContainsKey(page))
        {
            return pagePathes[page];
        }
        return null;
    }

    private void UnSubscribe()
    {
        foreach(var uIPage in uIPages)
        {
            uIPage.Unsubscribe();
        }
    }

    private List<IUIPage> FindAllPagesInChilds(GameObject game, string curPath)
    {
        if (UIRouter.CheckNameForURL(game.name))
        {
            string locPath = string.Empty;
            List<IUIPage> pageList = new List<IUIPage>(game.transform.childCount);
            List<GameObject> childss = GetAllChilds(game);
            foreach (GameObject child in childss)
            {
                IUIPage tryPage = null;
                if (child.TryGetComponent(out tryPage) && UIRouter.CheckNameForURL(child.name))
                {
                    locPath = UIRouter.slash + child.name;
                    if (pagePathes.ContainsValue(curPath + locPath))
                    {
                        Debug.LogError("All child objects of a canvas with an IUIPage must have unique names. Not a unique name " + child.name);
                        return null;
                    }
                    pagePathes.Add(tryPage, curPath + locPath);
                    pageList.Add(tryPage);
                }
                var childRes = FindAllPagesInChilds(child, curPath + locPath);
                if (childRes != null)
                {
                    pageList.AddRange(childRes);
                }
            }
            return pageList;
        }
        return null;
    }

    private void SubscribePages()
    {
        foreach (var page in uIPages) 
        {
            page.CreateURL(pagePathes[page]);
            page.Subscribe();
        }
        if (uIPages.Contains(mainPage))
        {
            UIRouter.SetMainScreenRoute(pagePathes[mainPage]);
        }
    }

    private List<GameObject> GetAllChilds(GameObject game)
    {
        int children = game.transform.childCount;
        List<GameObject> childs = new List<GameObject>();
        for (int i = 0; i < children; ++i)
        {
            childs.Add(game.transform.GetChild(i).gameObject);
        }
        return childs;
    }
}

В качестве типа главной страницы вынуждено указан PageWithTextController вместо IUIPage потому, что класс должен наследоваться от MonoBehaviour.

• FindAllPagesInChilds проходит по всем gameObject канваса, которые реализуют интерфейс IUIPages, проверяет имена на наличие синтаксиса url, записывает информацию о пути до них.

• SubscribePages подписывает все страницы в роутере, если страница указана как главная в инспекторе, то делается главной и в роутере.

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(CanvasManager))]
public class CanvasManagerInspector : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        var manager = target as CanvasManager;
        if (GUILayout.Button("Manually subscribe childs"))
        {
            manager.InitAllPages();
        }
    }
}