diff --git a/CHANGELOG.md b/CHANGELOG.md
index 911911a..57c13b6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,17 +1,17 @@
-#### **#2024/6/17 发布UniVue v1.0.0**
+## **#2024/6/17 发布UniVue v1.0.0**
 
 核心基础模块的完成
 
 
 
-#### **#2024/6/26修复UniVue v1.0.0中的BUG:** 
+## **#2024/6/26修复UniVue v1.0.0中的BUG:** 
 
 1. 基于ViewConfig构建的视图时，可能会重复生成UIEvent和UIBundle的问题;
 2. LoogGrid组件的布局错误问题;
 
 
 
-#### **#2024/6/26发布UniVue v1.0.1：核心模块优化**
+## **#2024/6/26发布UniVue v1.0.1**
 
 1. 优化VMTable，UI更新的复杂度为O(1)常数级;
 2. VueConfig继承自ScriptableObject;
@@ -20,17 +20,17 @@
 
 
 
-#### **#2024/6/27修复BUG**
+## **#2024/6/27修复BUG**
 
 1. 当ViewConfig的视图名称与文件名称不一致时导致错误的视图构建;
 
 
 
-#### **#2024/6/27将版本v1.0.1合并为v1.0.0**
+## **#2024/6/27将版本v1.0.1合并为v1.0.0**
 
 
 
-#### **#2024/6/29发布版本v1.1.0**
+## **#2024/6/29发布版本v1.1.0**
 
 1. IBindableModel继承新的接口IConsumableModel，此接口能够实现不要将模型绑定到视图而是直接将数据更新到UI上，这样可以为以下两种场景带来方便：	
 
@@ -43,7 +43,7 @@
 
 
 
-#### **#2024/7/9发布版本v1.2.0**
+## **#2024/7/9发布版本v1.2.0**
 
 1. **支持自定义规则**：对之前的规则引擎部分的代码进行完全重构，现在支持自定义规则（但是现在无法取代默认的规则实现），只需要实现接口IRuleFilter即可；
 
@@ -64,4 +64,15 @@
 
 7. 修复AtomModel、GroupModel对枚举类型无法进行执行UpdateModel()的bug；
 
-8. 修复ModelUtil对枚举类型无法执行UpdateModel()的bug；
\ No newline at end of file
+8. 修复ModelUtil对枚举类型无法执行UpdateModel()的bug；
+
+
+
+## **#2024/7/12发布版本v1.3.0**
+
+1. 新增ViewLevel.Modal级别的视图等级，Modal模态视图打开时如果不关闭此视图无法打开任何视图（就是之前版本的forbid=true时行为）；
+2. **优化System级别的视图的逻辑：现在System级别的视图为同级互斥。同级的含义指：具有相同的父视图，所有的根视图均为同一级。同级下永远只有一个System级别的视图被打开；**
+3. 当父视图没有被打开时不允许打开其子视图；
+4. 为事件系统新增IEntityMapper接口，为AOT编译提供基于非反射创建对象的实现，如果你的项目要进行IL2CPP编译，如果事件回调的参数有自定义的类型，你应该手动注册相应实体类型的接口实现，以实现事件回调时能够正确获得参数值；
+5. 优化视图的构建逻辑，**现在必须要求视图名称就是ViewObject.name，同时所有名称以"View"结尾的GameObject将被视为一个ViewObject对象**；
+6. 优化API的使用；
\ No newline at end of file
diff --git a/README.md b/README.md
index 83af534..874a3c5 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,37 @@
 
 
 
-## 版本功能一栏表
+## **开发说明**
+
+**说明：**由于每个版本的源码有变动，实现方式也有变化，之前下面讲解中使用的图中的某些函数的名字已经改名，可能某些流程也已经改变，但是由于个人精力有限，实在挤不出时间写更完善的文档了，只能每次一点一点的写。emmmm，如果你愿意和我一起维护这个开源项目，不妨联系我和我一起撸起袖子加油干！**QQ：2947897147**；
+
+我会在博客中对UniVue中的功能的使用进行讲解已经底层的实现逻辑、算法的实现。由于目前的电脑配置很差，开启Unity后录屏很卡，所有无法进行开视频进行讲解，emmm，后面升级装备了会在B站开视频进行讲解。保证最多一天的时间你就精通UniVue。
+
+CSDN个人博客：[Avalon712-CSDN博客](https://blog.csdn.net/m0_62135731?spm=1000.2115.3001.5343)
+
+这个仓库之后发布功能稳定的版本，因此很多最新的功能在这里是无法看见的，如果你想预览最新的功能，不妨fork一下这个仓库：https://github.com/Avalon712/UniVue-Develop 。这个仓库是我开发UniVue框架使用的项目，所有最新以及正在开发的功能都在这里可以看见，里面对每个功能都会有单元测试，也是学习UniVue框架的不二选择。
+
+
+
+**UniVue的扩展框架：UniVue源生成器**
+
+仓库地址：https://github.com/Avalon712/UniVue-SourceGenerator
+
+关于UniVue中源生成器更详细的说明，请看这篇博客：[UniVue更新日志：使用源生成器优化Model和ViewModel层的设计-CSDN博客](https://blog.csdn.net/m0_62135731/article/details/139525492?spm=1001.2014.3001.5501)
+
+
+
+**注：C#的源生器将会是完全替代反射的必要框架。通过生成低级代码完成对反射的替换，同时大幅度提高框架的易用性；**
+
+
+
+**版本说明**
+
+目前只对2021及其以上有支持，其它版本没试过，不知道什么情况，源码采用了很多C#9的语法，C#9似乎实在Unity2021开始支持的，如果你要使用源生器或许只能使用2021版本以上。同时不会对Unity都遗弃的功能进行支持，如：Text组件。因为如果对这些相同功能的组件也进行支持会导致ViewModel非常冗余，如果你要进行支持建议自己通过继承PropertyUI，然后看对于的组件是怎么实现更新逻辑的，照抄一遍就可以了。ViewModel的PropertyUI有将近30多个类，emmm，这就是我不打算支持的原因。后面PropertyUI还会进行扩展，可能会有70多个类。后续有时间了再看看要不要对2021版本以下的进行测试支持。
+
+
+
+## 版本核心功能一栏表
 
 ### **v1.0.0**
 
@@ -21,16 +51,23 @@
 
 
 
-**版本说明**
+### v1.1.0
 
-目前只对2021及其以上有支持，其它版本没试过，不知道什么情况，源码采用了很多C#9的语法，C#9似乎实在Unity2021开始支持的，如果你要使用源生器或许只能使用2021版本以上。同时不会对Unity都遗弃的功能进行支持，如：Text组件。因为如果对这些相同功能的组件也进行支持会导致ViewModel非常冗余，如果你要进行支持建议自己通过继承PropertyUI，然后看对于的组件是怎么实现更新逻辑的，照抄一遍就可以了。ViewModel的PropertyUI有将近40多个类，emmm，这就是我不打算支持的原因。后面PropertyUI还会进行扩展，可能会有70多个类。
+- **IConsumableModel接口**：在v1.0.0版本的基础上新增IConsumableModel接口的功能，实现更快的更新速度更少的查询缓存占用；
+- **源生成器同步更新至v1.1.0**：为支持IConsumableModel接口的功能，UniVue的源生成器提供了自动生成更新逻辑的代码；
 
 
 
-### v1.1.0
+### v1.2.0
 
-- **IConsumableModel接口**：在v1.0.0版本的基础上新增IConsumableModel接口的功能，实现更快的更新速度更少的查询缓存占用；
-- **源生成器同步更新至v1.1.0**：为支持IConsumableModel接口的功能，UniVue的源生成器提供了自动生成更新逻辑的代码；
+- **支持自定义规则**：v1.2.0版本中全面优化了规则引擎的代码，完全单独抽离出来成为一个独立的模块，UniVue的所有模块都依赖规则引擎模块；
+
+
+
+### v1.3.0
+
+- **新增Modal模态视图**：处于ViewLevel.Modal级别的视图被打开后，在关闭它之前，不允许任何视图再打开；
+- **优化System级别视图逻辑**：System级别的视图现在为同级互斥，具有相同父视图的视图为同一级，所有根视图（没有父视图的视图）为同一级；
 
 
 
@@ -48,24 +85,6 @@
 
 
 
-## **开发说明**
-
-**说明：**由于源码有变动，之前下面讲解中使用的图中的某些函数的名字已经改名，可能某些流程也已经改变，但是由于个人精力有限，实在挤不出时间写更完善的文档了，只能每次一点一点的写。emmmm，如果你愿意和我一起维护这个开源项目，不妨联系我和我一起撸起袖子加油干！**QQ：2947897147**；
-
-我会在博客中对UniVue中的功能的使用进行讲解已经底层的实现逻辑、算法的实现。由于目前的电脑配置很差，开启Unity后录屏很卡，所有无法进行开视频进行讲解，emmm，后面升级装备了会在B站开视频进行讲解。保证最多一天的时间你就精通UniVue。
-
-CSDN个人博客：[Avalon712-CSDN博客](https://blog.csdn.net/m0_62135731?spm=1000.2115.3001.5343)
-
-这个仓库之后发布功能稳定的版本，因此很多最新的功能在这里是无法看见的，如果你想预览最新的功能，不妨fork一下这个仓库：https://github.com/Avalon712/UniVue-Develop 。这个仓库是我开发UniVue框架使用的项目，所有最新以及正在开发的功能都在这里可以看见，里面对每个功能都会有单元测试，也是学习UniVue框架的不二选择。
-
-
-
-**UniVue的扩展框架：UniVue源生成器**
-
-仓库地址：https://github.com/Avalon712/UniVue-SourceGenerator
-
-关于UniVue中源生成器更详细的说明，请看这篇博客：[UniVue更新日志：使用源生成器优化Model和ViewModel层的设计-CSDN博客](https://blog.csdn.net/m0_62135731/article/details/139525492?spm=1001.2014.3001.5501)
-
 
 
 ## 一、简介
@@ -79,34 +98,34 @@ CSDN个人博客：[Avalon712-CSDN博客](https://blog.csdn.net/m0_62135731?spm=
 
 ### 视图加载流程
 
-
+见ViewBuilder类的实现
 
 ### 数据绑定流程
 
-
+见ViewUtil的实现
 
 ### UI更新流程
 
-
+见ViewUpdater或UIBundle的实现
 
 
 ### 模型更新流程
 
-
+见UIBundle的实现
 
 
 ### 事件触发流程
 
-
+见UIBundle、IBindableModel的实现
 
 
 ### 资源卸载流程
 
-
+见Vue
 
 ### 自动装配与卸载EventCall的执行逻辑
 
-
+见EventManager的实现
 
 ## 二、Model
 
@@ -306,7 +325,7 @@ UniVue除了提供实现数据、视图的双向绑定外还提供了强大的
 
 这个枚举类定义了常见的命名风格。注意：无论是哪种命名风格，指定UI组件名称都是必要的。
 
-#### 2）NamingRuleEngine
+#### 2）RuleEngine
 
  这个类实现了所有命名规则的解析、匹配。如果你的对命名还是不太清楚，可以看此类的源码，这个类是通过正则表达式来实现的解析和匹配。
 
@@ -747,6 +766,8 @@ UniVue除了提供实现数据、视图的双向绑定外还提供了强大的
 
 注意，多个命名规则下的顺序：**数据绑定 & 路由事件 & 自定义事件**
 
+**注：在v1.2.0以后无需关系顺序，任意顺序都可，同时无需再使用" & "隔开，但是基于可读性的基础上仍然建议这么做。**
+
 **举例说明：**
 
 - Player_Level_Slider & Arg_Grade[level]_Slider
@@ -825,7 +846,7 @@ View中具有嵌套关系时，在创建被嵌套的视图时，无需指定view
 
 在Unity的最上方的工具栏可以看见"**UniVue**"字样，点击，会出现提供的三个扩展功能。
 
-### ConfigEditorWindow**
+### ConfigEditorWindow
 
 位置: **UniVu > ConfigEditor**
 
@@ -843,9 +864,16 @@ View中具有嵌套关系时，在创建被嵌套的视图时，无需指定view
 
 - **以字符'~'开头的GameObject及其后代GameObject都不会被进行组件查找；**
 - **以字符'@'开头的GameObject不会被进行组件查找，但是其后代GameObject会被进行查找；**
+- 你可以通过修改VueConfig文件修改上述字符，使用其它字符完成；
 
 
 
 ## 十、源生成器
 
-最近的大更新中使用了源生成器来提高效率，关于UniVue中的源生成器，请看这篇博客：[UniVue更新日志：使用源生成器优化Model和ViewModel层的设计-CSDN博客](https://blog.csdn.net/m0_62135731/article/details/139525492?spm=1001.2014.3001.5501)
\ No newline at end of file
+最近的大更新中使用了源生成器来提高效率，关于UniVue中的源生成器，请看这篇博客：[UniVue更新日志：使用源生成器优化Model和ViewModel层的设计-CSDN博客](https://blog.csdn.net/m0_62135731/article/details/139525492?spm=1001.2014.3001.5501)
+
+
+
+## 十一、规则引擎
+
+通过自定义实现IRuleFilter接口，使用规则引擎RuleEngine能够对任何ViewObject执行Filter操作，过滤完后你可以对过滤的结果进行自定义的处理。规则引擎是所有模块的基础，后续的所有核心功能都依赖规则引擎。
\ No newline at end of file
diff --git a/UniVue/Runtime/Evt/EntityMapper.cs b/UniVue/Runtime/Evt/EntityMapper.cs
index 6ac3483..84490d0 100644
--- a/UniVue/Runtime/Evt/EntityMapper.cs
+++ b/UniVue/Runtime/Evt/EntityMapper.cs
@@ -12,16 +12,11 @@ public sealed class EntityMapper
         private EntityMapper() { }
 
         /// <summary>
-        /// 将事件参数映射为一个对象类型
+        /// 通过反射创建实体对象
         /// </summary>
-        /// <param name="type">对象类型</param>
-        /// <param name="args">参数</param>
-        /// <returns>映射对象</returns>
-        public static object Map(Type type, EventArg[] args)
+        public static object CreateEntity(Type type)
         {
-            object instance = Activator.CreateInstance(type);
-            SetValues(instance, args);
-            return instance;
+            return Activator.CreateInstance(type);
         }
 
         /// <summary>
diff --git a/UniVue/Runtime/Evt/EventArg.cs b/UniVue/Runtime/Evt/EventArg.cs
index d54b0bc..bcb132a 100644
--- a/UniVue/Runtime/Evt/EventArg.cs
+++ b/UniVue/Runtime/Evt/EventArg.cs
@@ -33,7 +33,7 @@ internal EventArg(string name, UIType type, Component argUI)
 
         public void SetArgumentValue(object value)
         {
-            SupportableArgType argType = EventUtil.GetSupportableArgType(value.GetType());
+            SupportableArgType argType = ReflectionUtil.GetSupportableArgType(value.GetType());
 
             if (argType == SupportableArgType.None || ((int)argType) > 6)
             {
diff --git a/UniVue/Runtime/Evt/EventCall.cs b/UniVue/Runtime/Evt/EventCall.cs
index eac8e8a..8d76593 100644
--- a/UniVue/Runtime/Evt/EventCall.cs
+++ b/UniVue/Runtime/Evt/EventCall.cs
@@ -86,27 +86,31 @@ private void SetParameterValues()
                     ParameterInfo parameter = parameters[i];
                     string argName = parameter.Name;
 
-                    SupportableArgType argType = EventUtil.GetSupportableArgType(parameter.ParameterType);
+                    SupportableArgType argType = ReflectionUtil.GetSupportableArgType(parameter.ParameterType);
 
                     if (argType == SupportableArgType.None) { continue; }
 
                     if ((int)argType < 7)
                     {
-                        SetArgMatchValue(argName, parameter.ParameterType, ref i, ref argType, ref args);
+                        SetArgMatchValue(argName, parameter.ParameterType, i, argType, args);
                     }
                     else
                     {
                         switch (argType)
                         {
                             case SupportableArgType.Custom:
-                                //重用之前创建的对象实例
-                                if (_parameters[i] != null)
+                                IEntityMapper mapper = Vue.Event.GetEntityMapper(parameter.ParameterType);
+                                if (mapper != null)
                                 {
-                                    EntityMapper.SetValues(_parameters[i], args);
+                                    if (_parameters[i] == null)
+                                        _parameters[i] = mapper.CreateEntity();
+                                    mapper.SetValues(_parameters[i], args);
                                 }
                                 else
                                 {
-                                    _parameters[i] = EntityMapper.Map(parameter.ParameterType, args);
+                                    if (_parameters[i] == null)
+                                        _parameters[i] = EntityMapper.CreateEntity(parameter.ParameterType);
+                                    EntityMapper.SetValues(_parameters[i], args);
                                 }
                                 break;
 
@@ -128,7 +132,7 @@ private void SetParameterValues()
             }
         }
 
-        private void SetArgMatchValue(string argName, Type parameterType, ref int i, ref SupportableArgType argType, ref EventArg[] args)
+        private void SetArgMatchValue(string argName, Type parameterType, int i, SupportableArgType argType, EventArg[] args)
         {
             //除开以上类型，以下这些类型将进行参数名与类型都匹配成功才能设置
             for (int j = 0; j < args.Length; j++)
@@ -204,17 +208,16 @@ private void SetArgMatchValue(string argName, Type parameterType, ref int i, ref
                         return;
                     }
 
-                    if (valueType != parameterType)
+                    if (valueType == parameterType)
                     {
-#if UNITY_EDITOR
-                        LogUtil.Warning($"方法[{_call.Name}]: 参数名为{argName}的类型为{parameterType}，与UI返回的事件参数类型{value.GetType()}不一致，无法正确进行赋值!");
-#endif
+                        _parameters[i] = value;
                     }
+#if UNITY_EDITOR
                     else
                     {
-                        _parameters[i] = value;
+                        LogUtil.Warning($"方法[{_call.Name}]: 参数名为{argName}的类型为{parameterType}，与UI返回的事件参数类型{value.GetType()}不一致，无法正确进行赋值!");
                     }
-
+#endif
                     return;
                 }
             }
diff --git a/UniVue/Runtime/Evt/EventManager.cs b/UniVue/Runtime/Evt/EventManager.cs
index 56d9cff..7497aa4 100644
--- a/UniVue/Runtime/Evt/EventManager.cs
+++ b/UniVue/Runtime/Evt/EventManager.cs
@@ -12,8 +12,13 @@ public sealed class EventManager
         private List<UIEvent> _events;
         private List<EventCall> _calls;
         private List<AutowireInfo> _autowires;
+        private List<IEntityMapper> _mappers;
 
-        internal EventManager() { _events = new(18); _calls = new(18); }
+        internal EventManager()
+        {
+            _events = new List<UIEvent>(20);
+            _calls = new List<EventCall>(10);
+        }
 
         internal List<UIEvent> Events => _events;
 
@@ -41,6 +46,27 @@ public void Signup<T>(T register) where T : IEventRegister
             }
         }
 
+        /// <summary>
+        /// 注册实体映射，将EventArg[]映射为自定义对象
+        /// </summary>
+        public void RegisterMapper(IEntityMapper mapper)
+        {
+            if (_mappers == null)
+                _mappers = new List<IEntityMapper>();
+            _mappers.Add(mapper);
+        }
+
+        public IEntityMapper GetEntityMapper(Type entityType)
+        {
+            if (_mappers == null) return null;
+            for (int i = 0; i < _mappers.Count; i++)
+            {
+                if (_mappers[i].EntityType == entityType)
+                    return _mappers[i];
+            }
+            return null;
+        }
+
         /// <summary>
         /// 自动装配EventCall
         /// </summary>
diff --git a/UniVue/Runtime/Evt/IEntityMapper.cs b/UniVue/Runtime/Evt/IEntityMapper.cs
new file mode 100644
index 0000000..409885a
--- /dev/null
+++ b/UniVue/Runtime/Evt/IEntityMapper.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace UniVue.Evt
+{
+    public interface IEntityMapper
+    {
+        public Type EntityType { get; }
+
+        public object CreateEntity();
+
+        public void SetValues(object entity, EventArg[] eventArgs);
+    }
+}
diff --git a/UniVue/Runtime/Evt/SupportableArgType.cs b/UniVue/Runtime/Evt/SupportableArgType.cs
new file mode 100644
index 0000000..94b8407
--- /dev/null
+++ b/UniVue/Runtime/Evt/SupportableArgType.cs
@@ -0,0 +1,24 @@
+
+namespace UniVue.Evt
+{
+    /// <summary>
+    /// EventCall支持的方法参数类型
+    /// </summary>
+    public enum SupportableArgType
+    {
+        /// <summary>
+        /// 不被支持的类型
+        /// </summary>
+        None,
+        Int,
+        Float,
+        String,
+        Enum,
+        Bool,
+        Sprite,
+        Custom,
+        UIEvent,
+        EventArg,
+        EventCall
+    }
+}
diff --git a/UniVue/Runtime/Rule/Filters/ModelFilter.cs b/UniVue/Runtime/Rule/Filters/ModelFilter.cs
index 4adf83e..50113d3 100644
--- a/UniVue/Runtime/Rule/Filters/ModelFilter.cs
+++ b/UniVue/Runtime/Rule/Filters/ModelFilter.cs
@@ -20,7 +20,9 @@ namespace UniVue.Rule
     /// </summary>
     public sealed class ModelFilter : IRuleFilter
     {
-        private readonly int _typeFlag;
+        private int _typeFlag;
+        private bool _allowUIUpdateModel;
+
         public string ModelName { get; private set; }
 
         public IBindableModel Model { get; private set; }
@@ -29,15 +31,14 @@ public sealed class ModelFilter : IRuleFilter
 
         public UIBundle Bundle { get; private set; }
 
-        public ModelFilter(IBindableModel model, string modelName = null)
+        public ModelFilter(IBindableModel model, bool allowUIUpdateModel = true, string modelName = null)
         {
             _typeFlag = -1;
             Model = model;
             ModelType = model.GetType();
-            ModelName = modelName;
-            Bundle = null;
             _typeFlag = GetTypeFlag();
             ModelName = GetModelName();
+            _allowUIUpdateModel = allowUIUpdateModel;
         }
 
         public bool Check(ref (Component, UIType) component, List<object> results)
@@ -54,7 +55,7 @@ public bool Check(ref (Component, UIType) component, List<object> results)
         public void OnComplete(List<object> results)
         {
             if (results.Count > 0)
-                Bundle = UIBundleBuilder.Build(Model, results);
+                Bundle = UIBundleBuilder.Build(Model, results, _allowUIUpdateModel);
         }
 
 
diff --git a/UniVue/Runtime/Rule/GlobalRule.cs b/UniVue/Runtime/Rule/GlobalRule.cs
index d14f40b..a9ae641 100644
--- a/UniVue/Runtime/Rule/GlobalRule.cs
+++ b/UniVue/Runtime/Rule/GlobalRule.cs
@@ -4,20 +4,17 @@
 using UnityEngine;
 using UnityEngine.UI;
 using UniVue.Utils;
-using UniVue.View.Views;
 
 namespace UniVue.Rule
 {
-    public static class GlobalRule
+    internal static class GlobalRule
     {
         /// <summary>
         /// 获取一个GameObject下所有的具有特殊命名的UI组件
         /// </summary>
-        /// <param name="gameObject">要找到组件的根对象</param>
-        /// <param name="view">指定当前的GameObject是否是ViewObject，如果是则需要传递此参数</param>
-        /// <param name="exclude">要排除的后代（这些GameObject的后代都不会进行查找）</param>
+        /// <param name="gameObject">要过滤的根对象</param>
         /// <returns>IEnumerable<ValueTuple<Component, UIType>></returns>
-        public static IEnumerable<ValueTuple<Component, UIType>> Filter(GameObject gameObject, IView view = null, params GameObject[] exclude)
+        public static IEnumerable<ValueTuple<Component, UIType>> Filter(GameObject gameObject)
         {
             char SKIP_ALL_DESCENDANT_SYMBOL = Vue.Config.SkipDescendantNodeSeparator;
             char SKIP_CURRENT_SYMBOL = Vue.Config.SkipCurrentNodeSeparator;
@@ -27,30 +24,6 @@ public static IEnumerable<ValueTuple<Component, UIType>> Filter(GameObject gameO
             ValueTuple<Component, UIType> result = new(null, UIType.None);
             queue.Enqueue(root);
 
-            //获取所有要跳过查找的GameObject节点
-            List<Transform> skipObjs = null;
-            if (view != null && !string.IsNullOrEmpty(view.Root))
-            {
-                skipObjs = new List<Transform>();
-                using (var v = view.GetNestedViews().GetEnumerator())
-                {
-                    while (v.MoveNext() && v.Current != null)
-                    {
-                        skipObjs.Add(v.Current.ViewObject.transform);
-                    }
-                }
-            }
-
-            if (exclude != null)
-            {
-                if (skipObjs == null)
-                    skipObjs = new List<Transform>(exclude.Length);
-                for (int i = 0; i < exclude.Length; i++)
-                {
-                    skipObjs.Add(exclude[i].transform);
-                }
-            }
-
             while (queue.Count > 0)
             {
                 Transform parent = queue.Dequeue();
@@ -59,9 +32,7 @@ public static IEnumerable<ValueTuple<Component, UIType>> Filter(GameObject gameO
                 {
                     Transform child = parent.GetChild(i);
 
-                    if (child.name.StartsWith(SKIP_ALL_DESCENDANT_SYMBOL)) { continue; }
-
-                    if (skipObjs != null && skipObjs.Contains(child)) { continue; }
+                    if (child.name.StartsWith(SKIP_ALL_DESCENDANT_SYMBOL) || child.name.EndsWith("View")) { continue; }
 
                     //非叶子节点再入队
                     if (child.childCount != 0)
@@ -91,52 +62,32 @@ private static void SetResult(ref ValueTuple<Component, UIType> result, GameObje
             {
                 case UIType.Image:
                     {
-                        Image image = gameObject.GetComponent<Image>();
-                        if (image != null)
-                        {
-                            result.Item1 = image;
-                            result.Item2 = UIType.Image;
-                        }
+                        result.Item1 = gameObject.GetComponent<Image>();
+                        result.Item2 = UIType.Image;
                         break;
                     }
                 case UIType.TMP_Dropdown:
                     {
-                        TMP_Dropdown dropdown = gameObject.GetComponent<TMP_Dropdown>();
-                        if (dropdown != null)
-                        {
-                            result.Item1 = dropdown;
-                            result.Item2 = UIType.TMP_Dropdown;
-                        }
+                        result.Item1 = gameObject.GetComponent<TMP_Dropdown>();
+                        result.Item2 = UIType.TMP_Dropdown;
                         break;
                     }
                 case UIType.TMP_Text:
                     {
-                        TMP_Text text = gameObject.GetComponent<TMP_Text>();
-                        if (text != null)
-                        {
-                            result.Item1 = text;
-                            result.Item2 = UIType.TMP_Text;
-                        }
+                        result.Item1 = gameObject.GetComponent<TMP_Text>();
+                        result.Item2 = UIType.TMP_Text;
                         break;
                     }
                 case UIType.TMP_InputField:
                     {
-                        TMP_InputField input = gameObject.GetComponent<TMP_InputField>();
-                        if (input != null)
-                        {
-                            result.Item1 = input;
-                            result.Item2 = UIType.TMP_InputField;
-                        }
+                        result.Item1 = gameObject.GetComponent<TMP_InputField>();
+                        result.Item2 = UIType.TMP_InputField;
                         break;
                     }
                 case UIType.Button:
                     {
-                        Button button = gameObject.GetComponent<Button>();
-                        if (button != null)
-                        {
-                            result.Item1 = button;
-                            result.Item2 = UIType.Button;
-                        }
+                        result.Item1 = gameObject.GetComponent<Button>();
+                        result.Item2 = UIType.Button;
                         break;
                     }
                 case UIType.Toggle:
@@ -151,12 +102,8 @@ private static void SetResult(ref ValueTuple<Component, UIType> result, GameObje
                     }
                 case UIType.Slider:
                     {
-                        Slider slider = gameObject.GetComponent<Slider>();
-                        if (slider != null)
-                        {
-                            result.Item1 = slider;
-                            result.Item2 = UIType.Slider;
-                        }
+                        result.Item1 = gameObject.GetComponent<Slider>();
+                        result.Item2 = UIType.Slider;
                         break;
                     }
             }
diff --git a/UniVue/Runtime/Rule/RuleEngine.cs b/UniVue/Runtime/Rule/RuleEngine.cs
index 52e9bb9..cec4c18 100644
--- a/UniVue/Runtime/Rule/RuleEngine.cs
+++ b/UniVue/Runtime/Rule/RuleEngine.cs
@@ -18,28 +18,7 @@ internal RuleEngine()
 
         public void Filter(GameObject gameObject, IRuleFilter filter)
         {
-            Filter(gameObject, filter, null, null);
-        }
-
-        public void BatchFilter(GameObject gameObject, IRuleFilter[] filters)
-        {
-            for (int i = 0; i < filters.Length; i++)
-            {
-                Filter(gameObject, filters[i]);
-            }
-        }
-
-        public void Filter(GameObject gameObject, IRuleFilter[] filters, IView view, params GameObject[] exclude)
-        {
-            for (int i = 0; i < filters.Length; i++)
-            {
-                Filter(gameObject, filters[i], view, exclude);
-            }
-        }
-
-        public void Filter(GameObject gameObject, IRuleFilter filter, IView view, params GameObject[] exclude)
-        {
-            using (var it = GlobalRule.Filter(gameObject, view, exclude).GetEnumerator())
+            using (var it = GlobalRule.Filter(gameObject).GetEnumerator())
             {
                 while (it.MoveNext())
                 {
@@ -51,6 +30,13 @@ public void Filter(GameObject gameObject, IRuleFilter filter, IView view, params
             _results.Clear();
         }
 
+        public void Filter(GameObject gameObject, IRuleFilter[] filters, bool parallel = true)
+        {
+            if (parallel)
+                ParallelFilter(gameObject, filters);
+            else
+                SequenceFilter(gameObject, filters);
+        }
 
         /// <summary>
         /// 对当前场景下视图的所有UI组件进行过滤
@@ -62,12 +48,45 @@ public void FilterAll(IRuleFilter filter)
                 while (it.MoveNext())
                 {
                     IView view = it.Current;
-                    //只对根视图进行过滤即可
-                    if (string.IsNullOrEmpty(view.Root))
-                        Filter(view.ViewObject, filter);
+                    Filter(view.ViewObject, filter);
                 }
             }
         }
 
+
+        private void SequenceFilter(GameObject gameObject, IRuleFilter[] filters)
+        {
+            for (int i = 0; i < filters.Length; i++)
+            {
+                Filter(gameObject, filters[i]);
+            }
+        }
+
+        private void ParallelFilter(GameObject gameObject, IRuleFilter[] filters)
+        {
+            List<object>[] results = new List<object>[filters.Length];
+            for (int i = 0; i < filters.Length; i++)
+            {
+                results[i] = new List<object>();
+            }
+
+            using (var it = GlobalRule.Filter(gameObject).GetEnumerator())
+            {
+                while (it.MoveNext())
+                {
+                    ValueTuple<Component, UIType> comp = it.Current;
+                    for (int i = 0; i < filters.Length; i++)
+                    {
+                        filters[i].Check(ref comp, results[i]);
+                    }
+                }
+            }
+
+            for (int i = 0; i < filters.Length; i++)
+            {
+                filters[i].OnComplete(results[i]);
+                results[i].Clear();
+            }
+        }
     }
 }
diff --git a/UniVue/Runtime/Utils/EventUtil.cs b/UniVue/Runtime/Utils/EventUtil.cs
deleted file mode 100644
index e50ff6a..0000000
--- a/UniVue/Runtime/Utils/EventUtil.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-using System;
-using UnityEngine;
-using UniVue.Evt;
-using UniVue.Evt.Evts;
-
-namespace UniVue.Utils
-{
-    public sealed class EventUtil
-    {
-        private EventUtil() { }
-
-        public static SupportableArgType GetSupportableArgType(Type type)
-        {
-            if (type == typeof(string)) { return SupportableArgType.String; }
-            if (type == typeof(int)) { return SupportableArgType.Int; }
-            if (type == typeof(float)) { return SupportableArgType.Float; }
-            if (type == typeof(bool)) { return SupportableArgType.Bool; }
-            if (type.IsEnum) { return SupportableArgType.Enum; }
-            if (type == typeof(Sprite)) { return SupportableArgType.Sprite; }
-            if (type == typeof(UIEvent)) { return SupportableArgType.UIEvent; }
-            if (type == typeof(EventCall)) { return SupportableArgType.EventCall; }
-            if (type == typeof(EventArg[])) { return SupportableArgType.EventArg; }
-            if (ReflectionUtil.IsCustomType(type)) { return SupportableArgType.Custom; } //必须防止最后一个进行判断
-            return SupportableArgType.None;
-        }
-    }
-
-    /// <summary>
-    /// EventCall支持的方法参数类型
-    /// </summary>
-    public enum SupportableArgType
-    {
-        /// <summary>
-        /// 不被支持的类型
-        /// </summary>
-        None,
-        Int,
-        Float,
-        String,
-        Enum,
-        Bool,
-        Sprite,
-        Custom,
-        UIEvent,
-        EventArg,
-        EventCall
-    }
-}
diff --git a/UniVue/Runtime/Utils/PrefabCloneUtil.cs b/UniVue/Runtime/Utils/PrefabCloneUtil.cs
index fbad943..25e6ead 100644
--- a/UniVue/Runtime/Utils/PrefabCloneUtil.cs
+++ b/UniVue/Runtime/Utils/PrefabCloneUtil.cs
@@ -2,10 +2,8 @@
 
 namespace UniVue.Utils
 {
-    public sealed class PrefabCloneUtil
+    public static class PrefabCloneUtil
     {
-        private PrefabCloneUtil() { }
-
         public static GameObject RectTransformClone(GameObject prefab, Transform parent)
         {
             GameObject clone = GameObject.Instantiate(prefab, parent);
diff --git a/UniVue/Runtime/Utils/ReflectionUtil.cs b/UniVue/Runtime/Utils/ReflectionUtil.cs
index 7e226ea..52da608 100644
--- a/UniVue/Runtime/Utils/ReflectionUtil.cs
+++ b/UniVue/Runtime/Utils/ReflectionUtil.cs
@@ -4,14 +4,28 @@
 using UnityEngine;
 using UniVue.Evt;
 using UniVue.Evt.Attr;
+using UniVue.Evt.Evts;
 using UniVue.Model;
 using UniVue.ViewModel;
 
 namespace UniVue.Utils
 {
-    public sealed class ReflectionUtil
+    public static class ReflectionUtil
     {
-        private ReflectionUtil() { }
+        public static SupportableArgType GetSupportableArgType(Type type)
+        {
+            if (type == typeof(string)) { return SupportableArgType.String; }
+            if (type == typeof(int)) { return SupportableArgType.Int; }
+            if (type == typeof(float)) { return SupportableArgType.Float; }
+            if (type == typeof(bool)) { return SupportableArgType.Bool; }
+            if (type.IsEnum) { return SupportableArgType.Enum; }
+            if (type == typeof(Sprite)) { return SupportableArgType.Sprite; }
+            if (type == typeof(UIEvent)) { return SupportableArgType.UIEvent; }
+            if (type == typeof(EventCall)) { return SupportableArgType.EventCall; }
+            if (type == typeof(EventArg[])) { return SupportableArgType.EventArg; }
+            if (ReflectionUtil.IsCustomType(type)) { return SupportableArgType.Custom; } //必须防止最后一个进行判断
+            return SupportableArgType.None;
+        }
 
         public static BindableType GetBindableType(Type type)
         {
diff --git a/UniVue/Runtime/Utils/ViewUtil.cs b/UniVue/Runtime/Utils/ViewUtil.cs
index 4865128..f200e83 100644
--- a/UniVue/Runtime/Utils/ViewUtil.cs
+++ b/UniVue/Runtime/Utils/ViewUtil.cs
@@ -54,8 +54,8 @@ public static void BindModel(IView view, IBindableModel model, bool allowUIUpdat
             //当前尚未为此模型生成任何UIBundle对象
             if (bundle == null)
             {
-                ModelFilter filter = new ModelFilter(model, modelName);
-                Vue.Rule.Filter(view.ViewObject, filter, view);
+                ModelFilter filter = new ModelFilter(model, allowUIUpdateModel, modelName);
+                Vue.Rule.Filter(view.ViewObject, filter);
                 bundle = filter.Bundle;
                 Vue.Updater.BindViewModel(view.Name, bundle);
                 model.UpdateAll(bundle);
@@ -80,7 +80,7 @@ public static void BindModel(GameObject viewObject, IBindableModel model, bool a
             //当前尚未为此模型生成任何UIBundle对象
             if (bundle == null)
             {
-                ModelFilter filter = new ModelFilter(model, modelName);
+                ModelFilter filter = new ModelFilter(model, allowUIUpdateModel, modelName);
                 Vue.Rule.Filter(viewObject, filter);
                 bundle = filter.Bundle;
                 Vue.Updater.BindViewModel(viewObject.name, bundle);
@@ -106,30 +106,7 @@ public static void BindModel(GameObject viewObject, IBindableModel model, bool a
         /// <param name="viewObject"></param>
         /// <param name="model">要绑定的模型</param>
         /// <param name="exclued">要排除的GameObject</param>
-        public static void Patch3Pass(GameObject viewObject, IBindableModel model, params GameObject[] exclued)
-        {
-            Patch3Pass(viewObject, model, null, exclued);
-        }
-
-
-        /// <summary>
-        /// 同时完成两个处理流程：构建UIEvent、绑定路由事件
-        /// </summary>
-        /// <param name="viewObject">GameObject</param>
-        /// <param name="exclued">要排除的GameObject</param>
-        public static void Patch2Pass(GameObject viewObject, params GameObject[] exclued)
-        {
-            Patch2Pass(viewObject, null, exclued);
-        }
-
-        /// <summary>
-        /// 同时完成三个处理流程：构建UIEvent、绑定路由事件、绑定模型
-        /// </summary>
-        /// <remarks>这种方式无需创建视图对象(BaseView)</remarks>
-        /// <param name="viewObject"></param>
-        /// <param name="model">要绑定的模型</param>
-        /// <param name="exclued">要排除的GameObject</param>
-        public static void Patch3Pass(GameObject viewObject, IBindableModel model, IView view, params GameObject[] exclued)
+        public static void Patch3Pass(GameObject viewObject, IBindableModel model)
         {
 #if UNITY_EDITOR
             if (Vue.Updater.Table.ContainsViewName(viewObject.name))
@@ -139,10 +116,10 @@ public static void Patch3Pass(GameObject viewObject, IBindableModel model, IView
 #endif
 
             ModelFilter modelFilter = new ModelFilter(model);
-            EventFilter eventFilter = new EventFilter(view == null ? viewObject.name : view.Name);
-            RouteFilter routeFilter = new RouteFilter(view == null ? viewObject.name : view.Name);
+            EventFilter eventFilter = new EventFilter(viewObject.name);
+            RouteFilter routeFilter = new RouteFilter(viewObject.name);
 
-            Vue.Rule.Filter(viewObject, new IRuleFilter[3] { modelFilter, eventFilter, routeFilter }, view, exclued);
+            Vue.Rule.Filter(viewObject, new IRuleFilter[3] { modelFilter, eventFilter, routeFilter });
 
             UIBundle bundle = modelFilter.Bundle;
             Vue.Updater.BindViewModel(viewObject.name, bundle);
@@ -154,8 +131,7 @@ public static void Patch3Pass(GameObject viewObject, IBindableModel model, IView
         /// 同时完成两个处理流程：构建UIEvent、绑定路由事件
         /// </summary>
         /// <param name="viewObject">GameObject</param>
-        /// <param name="exclued">要排除的GameObject</param>
-        public static void Patch2Pass(GameObject viewObject, IView view, params GameObject[] exclued)
+        public static void Patch2Pass(GameObject viewObject)
         {
 #if UNITY_EDITOR
             if (Vue.Updater.Table.ContainsViewName(viewObject.name))
@@ -163,10 +139,10 @@ public static void Patch2Pass(GameObject viewObject, IView view, params GameObje
                 LogUtil.Warning($"表中已经存在了一个相同名称{viewObject.name}的ViewObject,这可能将导致错误的结果,你应该确保viewName的唯一性");
             }
 #endif
-            EventFilter eventFilter = new EventFilter(view == null ? viewObject.name : view.Name);
-            RouteFilter routeFilter = new RouteFilter(view == null ? viewObject.name : view.Name);
+            EventFilter eventFilter = new EventFilter(viewObject.name);
+            RouteFilter routeFilter = new RouteFilter(viewObject.name);
 
-            Vue.Rule.Filter(viewObject, new IRuleFilter[2] { eventFilter, routeFilter }, view, exclued);
+            Vue.Rule.Filter(viewObject, new IRuleFilter[2] { eventFilter, routeFilter });
         }
 
 
@@ -191,7 +167,7 @@ public static UIBundle Patch3PassButNoBinding(GameObject viewObject, IBindableMo
             EventFilter eventFilter = new EventFilter(viewObject.name);
             RouteFilter routeFilter = new RouteFilter(viewObject.name);
 
-            Vue.Rule.Filter(viewObject, new IRuleFilter[3] { modelFilter, eventFilter, routeFilter }, null, exclued);
+            Vue.Rule.Filter(viewObject, new IRuleFilter[3] { modelFilter, eventFilter, routeFilter });
 
             return modelFilter.Bundle;
         }
@@ -200,9 +176,9 @@ public static UIBundle Patch3PassButNoBinding(GameObject viewObject, IBindableMo
         /// 构建UI事件
         /// </summary>
         /// <param name="exclued">要排除的GameObject</param>
-        public static void BuildUIEvents(GameObject viewObject, params GameObject[] exclued)
+        public static void BuildUIEvents(GameObject viewObject)
         {
-            Vue.Rule.Filter(viewObject, new EventFilter(viewObject.name), null, exclued);
+            Vue.Rule.Filter(viewObject, new EventFilter(viewObject.name));
         }
 
 
@@ -210,9 +186,9 @@ public static void BuildUIEvents(GameObject viewObject, params GameObject[] excl
         /// 构建路由事件
         /// </summary>
         /// <param name="exclued">要排除的GameObject</param>
-        public static void BuildRoutEvents(GameObject viewObject, params GameObject[] exclued)
+        public static void BuildRoutEvents(GameObject viewObject)
         {
-            Vue.Rule.Filter(viewObject, new RouteFilter(viewObject.name), null, exclued);
+            Vue.Rule.Filter(viewObject, new RouteFilter(viewObject.name));
         }
     }
 }
diff --git a/UniVue/Runtime/View/Config/ClampListViewConfig.cs b/UniVue/Runtime/View/Config/ClampListViewConfig.cs
index 8680137..9274a7a 100644
--- a/UniVue/Runtime/View/Config/ClampListViewConfig.cs
+++ b/UniVue/Runtime/View/Config/ClampListViewConfig.cs
@@ -14,7 +14,7 @@ internal override IView CreateView(GameObject viewObject)
         {
             var content = GameObjectFindUtil.BreadthFind(_content, viewObject)?.transform;
             ClampList comp = new(content);
-            ClampListView view = new(comp, viewObject, viewName, level);
+            ClampListView view = new(comp, viewObject, level);
             BaseSettings(view);
             return view;
         }
diff --git a/UniVue/Runtime/View/Config/EnsureTipViewConfig.cs b/UniVue/Runtime/View/Config/EnsureTipViewConfig.cs
index 9969566..04206ab 100644
--- a/UniVue/Runtime/View/Config/EnsureTipViewConfig.cs
+++ b/UniVue/Runtime/View/Config/EnsureTipViewConfig.cs
@@ -60,7 +60,7 @@ internal override IView CreateView(GameObject viewObject)
             }
 
             EnsureTip comp = new(name, cancelBtn, sureBtn, message, title);
-            EnsureTipView view = new(comp, viewObject, viewName, level);
+            EnsureTipView view = new(comp, viewObject, level);
             BaseSettings(view);
             return view;
         }
diff --git a/UniVue/Runtime/View/Config/GridViewConfig.cs b/UniVue/Runtime/View/Config/GridViewConfig.cs
index 1ff3a4c..a5bbca9 100644
--- a/UniVue/Runtime/View/Config/GridViewConfig.cs
+++ b/UniVue/Runtime/View/Config/GridViewConfig.cs
@@ -43,7 +43,7 @@ internal override IView CreateView(GameObject viewObject)
                 PlayScrollEffectOnRefresh = _playScrollEffectOnRefresh
             };
 
-            GridView view = new(gridComp, viewObject, viewName, level);
+            GridView view = new(gridComp, viewObject, level);
             BaseSettings(view);
             return view;
         }
diff --git a/UniVue/Runtime/View/Config/ListViewConfig.cs b/UniVue/Runtime/View/Config/ListViewConfig.cs
index cfc277d..549a764 100644
--- a/UniVue/Runtime/View/Config/ListViewConfig.cs
+++ b/UniVue/Runtime/View/Config/ListViewConfig.cs
@@ -45,7 +45,7 @@ internal override IView CreateView(GameObject viewObject)
                 PlayScrollEffectOnRefresh = _playScrollEffectOnRefresh
             };
 
-            ListView view = new ListView(listComp, viewObject, viewName, level);
+            ListView view = new ListView(listComp, viewObject, level);
             BaseSettings(view);
             return view;
         }
diff --git a/UniVue/Runtime/View/Config/TipViewConfig.cs b/UniVue/Runtime/View/Config/TipViewConfig.cs
index 36ec307..e28fc6f 100644
--- a/UniVue/Runtime/View/Config/TipViewConfig.cs
+++ b/UniVue/Runtime/View/Config/TipViewConfig.cs
@@ -23,7 +23,7 @@ internal override IView CreateView(GameObject viewObject)
             }
             Tip tipComp = new(viewName, contentTxt);
 
-            TipView view = new(tipComp, viewObject, viewName, level);
+            TipView view = new(tipComp, viewObject, level);
             BaseSettings(view);
             return view;
         }
diff --git a/UniVue/Runtime/View/Config/ViewConfig.cs b/UniVue/Runtime/View/Config/ViewConfig.cs
index c60ec82..71d6742 100644
--- a/UniVue/Runtime/View/Config/ViewConfig.cs
+++ b/UniVue/Runtime/View/Config/ViewConfig.cs
@@ -11,7 +11,7 @@ namespace UniVue.View.Config
     /// </summary>
     public class ViewConfig : ScriptableObject
     {
-        [Tooltip("当前视图在Canvas下的排序,序号越小越先被渲染")]
+        [Tooltip("当前视图在Canvas下的排序,序号越小越先被渲染,只对根视图有效")]
         [Range(0, 20)]
         public int order = 0;
 
@@ -22,14 +22,14 @@ public class ViewConfig : ScriptableObject
         [Tooltip("视图对象预制体")]
         public GameObject viewObjectPrefab;
 
-        [Tooltip("ViewLevel.Transient视图显示时间")]
-        public float transientTime = -1;
+        [Header("当前视图的父视图名称")]
+        public string parent;
 
         [Tooltip("设置当前视图的初始状态,true:打开状态")]
         public bool initState;
 
-        [Tooltip("设置当前View被打开时是否禁止再打开其它视图")]
-        public bool forbid;
+        [Tooltip("ViewLevel.Transient视图显示时间")]
+        public float transientTime = -1;
 
         [Tooltip("视图的拖拽配置信息")]
         public DragInputConfig[] _dragInputConfigs;
@@ -48,16 +48,6 @@ public class ViewConfig : ScriptableObject
         [Tooltip("仅在非DefaultTween.None时生效。关闭动画的持续时间，小于0表示使用默认的缓动时间")]
         public float closeDuration = -1;
 
-        [Header("当前视图是否是属主视图")]
-        public bool isMaster;
-
-        [Tooltip("为当前视图设置控制对象，只有当master视图处于打开状态则允许当前视图的打开、关闭；如果master视图被关闭则当前视图也会被关闭")]
-        [Header("该视图的属主视图")]
-        public string master;
-
-        [Header("当前视图的根视图名称")]
-        public string root;
-
         [Header("当前视图的嵌套的所有视图")]
         public ViewConfig[] nestedViews;
 
@@ -66,27 +56,26 @@ internal virtual IView CreateView(GameObject viewObject)
         {
             ViewUtil.SetActive(viewObject, initState);
 
-            var view = new BaseView(viewObject, viewName, level);
+            BaseView view = new BaseView(viewObject, level);
             BaseSettings(view);
 
             return view;
         }
 
-        protected void BaseSettings<T>(T view) where T : BaseView
+        protected void BaseSettings(BaseView view)
         {
-            //视图序号设置
-            view.Order = order;
+            //当前视图的父视图
+            view.Parent = parent;
+
             //视图打开关闭模块
-            view.IsMaster = isMaster;
-            view.Root = root;
-            view.Master = master;
-            view.Forbid = forbid;
             view.transientTime = transientTime;
+
             //动画模块设置
             view.openTween = openTween;
             view.openDuration = openDuration;
             view.closeTween = closeTween;
             view.closeDuration = closeDuration;
+
             //拖拽设置
             view.SetDraggable(_dragInputConfigs);
         }
diff --git a/UniVue/Runtime/View/ViewBuilder.cs b/UniVue/Runtime/View/ViewBuilder.cs
index 5ca9d12..60882b3 100644
--- a/UniVue/Runtime/View/ViewBuilder.cs
+++ b/UniVue/Runtime/View/ViewBuilder.cs
@@ -10,10 +10,8 @@ namespace UniVue.View
     /// <summary>
     /// 视图构建器
     /// </summary>
-    public sealed class ViewBuilder
+    public static class ViewBuilder
     {
-        private ViewBuilder() { }
-
         public static void Build(SceneConfig config)
         {
             Build(config.canvasConfigs);
@@ -30,7 +28,7 @@ private static void Build(CanvasConfig[] canvasConfigs)
             }
         }
 
-        private static void Build(CanvasConfig canvasConfig)
+        public static void Build(CanvasConfig canvasConfig)
         {
             GameObject canvas = GameObject.Find(canvasConfig.canvasName);
 
@@ -60,21 +58,14 @@ public static void Build(GameObject canvas, ViewConfig[] viewConfigs)
             FindNestedViewObject(roots, 0);
 
             //2.按嵌套层级从深往浅进行加载视图
-            List<IView> views = new List<IView>(roots.Count);
             roots.Sort((r1, r2) => r2.Item3 - r1.Item3); //降序排序
             for (int i = 0; i < roots.Count; i++)
             {
-                views.Add(roots[i].Item1.CreateView(roots[i].Item2));
-            }
-
-            //3. 维持配置的嵌套视图的关系
-            for (int i = 0; i < viewConfigs.Length; i++)
-            {
-                ViewConfig config = viewConfigs[i];
-                KeepNested(config);
+                IView view = roots[i].Item1.CreateView(roots[i].Item2);
+                view.OnLoad();
             }
 
-            //4. 按order层级进行排序 : 只对根视图执行排序操作
+            //3. 按order层级进行排序 : 只对根视图执行排序操作
             roots.Sort((r1, r2) => r1.Item1.order - r2.Item1.order); //升序排序，因为order值越大越先被渲染
             for (int i = 0; i < roots.Count; i++)
             {
@@ -83,31 +74,8 @@ public static void Build(GameObject canvas, ViewConfig[] viewConfigs)
                     roots[i].Item2.transform.SetAsLastSibling();
                 }
             }
-
-            //5.调用OnLoad()函数
-            for (int i = 0; i < views.Count; i++)
-            {
-                views[i].OnLoad();
-            }
         }
 
-        /// <summary>
-        /// 维护配置的视图的嵌套关系
-        /// </summary>
-        private static void KeepNested(ViewConfig viewConfig)
-        {
-            ViewConfig[] nestedViews = viewConfig?.nestedViews;
-            if (viewConfig == null || nestedViews == null || nestedViews.Length == 0)
-                return;
-
-            BaseView view = Vue.Router.GetView(viewConfig.viewName) as BaseView;
-            view.nestedViews = new IView[nestedViews.Length];
-            for (int i = 0; i < nestedViews.Length; i++)
-            {
-                view.nestedViews[i] = Vue.Router.GetView(nestedViews[i].viewName);
-                KeepNested(nestedViews[i]);
-            }
-        }
 
         /// <summary>
         /// 加载指定层级的嵌套视图的ViewObject
diff --git a/UniVue/Runtime/View/ViewLevel.cs b/UniVue/Runtime/View/ViewLevel.cs
index 41296a8..8a54281 100644
--- a/UniVue/Runtime/View/ViewLevel.cs
+++ b/UniVue/Runtime/View/ViewLevel.cs
@@ -14,12 +14,18 @@ public enum ViewLevel
         Common,
 
         /// <summary>
-        /// 系统级，只允许存在一个System级的视图被打开
+        /// 系统级，同级视图中只允许存在一个System级的视图被打开
         /// </summary>
+        /// <remarks>同级指拥有相同父视图的视图(所有根视图属于同一级)</remarks>
         System,
 
         /// <summary>
-        /// 持久级，不会被关闭的ViewPanel
+        /// 模态级，不关闭此视图无法打开任何视图
+        /// </summary>
+        Modal,
+
+        /// <summary>
+        /// 持久级，不会被"关闭"的视图
         /// </summary>
         Permanent,
 
diff --git a/UniVue/Runtime/View/ViewRouter.cs b/UniVue/Runtime/View/ViewRouter.cs
index 5cf308a..6a2e995 100644
--- a/UniVue/Runtime/View/ViewRouter.cs
+++ b/UniVue/Runtime/View/ViewRouter.cs
@@ -5,7 +5,7 @@
 namespace UniVue.View
 {
     /// <summary>
-    /// 管理ViewPanel的行为
+    /// 管理所有视图的打开、关闭逻辑
     /// </summary>
     public sealed class ViewRouter
     {
@@ -41,9 +41,8 @@ public IEnumerable<IView> GetAllView()
 
         public T GetView<T>(string viewName) where T : IView
         {
-            if (string.IsNullOrEmpty(viewName)) { return default; }
-            if (_views.ContainsKey(viewName)) { return (T)_views[viewName]; }
-            return default;
+            IView view = GetView(viewName);
+            return view != null ? (T)view : default;
         }
 
         public void UnloadView(string viewName)
@@ -125,88 +124,59 @@ public void Open(string viewName, bool top = true)
             //2.检查是否为Permanent级别
             if (opening.State || opening.Level == ViewLevel.Permanent) { return; }
 
-            //3.检验当前是否有一个ForbidOpenOther的视图被打开 
+            //3.检验当前是否有一个Modal视图被打开 
             IView opened = GetView(CurrentOpenedView()); //当前被打开的视图
-            if (opened != null && opened.Forbid)
+            if (opened != null && opened.Level == ViewLevel.Modal)
             {
 #if UNITY_EDITOR
-                LogUtil.Warning($"当前被打开的视图viewName={opened.Name}禁止打开viewName={viewName}的视图，无法再打开其它视图，除非关闭它");
+                LogUtil.Warning($"当前有一个模态Modal视图被打开[viewName={opened.Name}],无法对视图viewName={opening.Name}执行打开操作，无法再打开其它视图，除非关闭它");
 #endif
                 return;
             }
 
-            //4.检验是否被关联 是则看关联主体是否被打开->否则拒绝打开
-            if (!string.IsNullOrEmpty(opening.Master))
-            {
-                string masterViewName = opening.Master;
-                if (!GetView(masterViewName).State)
-                {
-#if UNITY_EDITOR
-                    LogUtil.Warning($"名称为{viewName}的视图已被关联到一个{masterViewName}的视图，而它没有被打开，因此无法打开{opening.Name}视图!");
-#endif
-                    return;
-                }
-            }
-
-            //5.检查根视图是否被打开（如果存在的话），是则要看根视图是否被打开->否则拒绝打开
-            string rootViewName = opening.Root;
-            if (!string.IsNullOrEmpty(rootViewName) && !GetView(rootViewName).State)
+            //4.检查其父视图是否被打开
+            IView parent = GetView(opening.Parent);
+            if (parent != null && !parent.State)
             {
 #if UNITY_EDITOR
-                LogUtil.Warning($"当前打开的视图与名称为{rootViewName}的视图存在父子关系，而此视图的父视图没有被打开，因此无法打开{viewName}视图!");
+                LogUtil.Warning($"当前正在执行打开操作的视图{viewName}的父视图{parent.Name}尚未被打开，只有先打开其父视图才允许其被打开！");
 #endif
                 return;
             }
 
-            //6.System级别视图的打开逻辑
+            //5. System级别的视图打开逻辑：同级互斥，关闭上一个与当前正在打开的视图同一级的已经打开了的System级的视图
             if (opening.Level == ViewLevel.System)
             {
-                //6.1如果当前打开的系统级别的视图有根视图，则只能关闭相同根视图的系统级别视图
-                if (!string.IsNullOrEmpty(opening.Root))
+                for (int i = 0; i < _histories.Count; i++)
                 {
-                    for (int i = 0; i < _histories.Count; i++)
+                    IView view = GetView(_histories[i]);
+                    if (view.State && view.Level == ViewLevel.System && view.Parent == opening.Parent)
                     {
-                        IView view = GetView(_histories[i]);
-                        if (view.State && view.Level == ViewLevel.System && view.Root == opening.Root)
-                        {
-                            Close(view.Name);
-                        }
-                    }
-                }
-
-                //6.2如果当前打开的系统级别的视图没有有根视图，则只能关闭上一个打开的同样没有根视图的系统级别视图
-                else
-                {
-                    for (int i = 0; i < _histories.Count; i++)
-                    {
-                        IView view = GetView(_histories[i]);
-                        if (view.State && view.Level == ViewLevel.System && string.IsNullOrEmpty(view.Root))
-                        {
-                            Close(view.Name);
-                        }
+                        Close(view.Name);
+                        break; //跳出的原因：同级中永远只有一个System级的视图被打开
                     }
                 }
             }
 
-            //7.将其设置为最后一个子物体，保证被打开的视图能被显示，只对根视图有效
-            if (top && string.IsNullOrEmpty(opening.Root))
+            //6.将其设置为最后一个子物体，保证被打开的视图能被显示，只对根视图有效
+            if (top && string.IsNullOrEmpty(opening.Parent))
             {
                 opening.ViewObject.transform.SetAsLastSibling();
             }
 
-            //8.播放音效
+            //7.播放音效
             _audioEffectCtr?.PlayAudioEffect(viewName);
 
-            //9.设置状态
+            //8.设置状态
             IsRouterCtrl = true;
 
-            //10.打开视图
+            //9.打开视图
             opening.Open();
 
-            //11.执行回调
+            //10.执行回调
             _audioEffectCtr?.AfterOpen(viewName);
 
-            //12.加入历史记录中，只有不为瞬态的视图才加入
+            //11.加入历史记录中，只有不为瞬态的视图才加入
             if (opening.Level != ViewLevel.Transient)
             {
                 //如果当前历史记录里面已经有过其记录，则先移除再添加
@@ -214,7 +184,7 @@ public void Open(string viewName, bool top = true)
                 ListUtil.AddButNoOutOfCapacity(_histories, viewName);
             }
 
-            //13.设置状态
+            //12.设置状态
             IsRouterCtrl = false;
         }
 
@@ -235,10 +205,9 @@ public void Close(string viewName)
             }
 
             //1.检查当前视图是否以及处于关闭状态
-            //2.检查是否为Permanent级别
             if (!closing.State) { return; }
 
-            //2.视图级别检查
+            //2.检查是否为Permanent级别
             if (closing.Level == ViewLevel.Permanent)
             {
 #if UNITY_EDITOR
@@ -247,44 +216,16 @@ public void Close(string viewName)
                 return;
             }
 
-            //3.检查是否被关联
-            if (!string.IsNullOrEmpty(closing.Master))
-            {
-                IView master = GetView(closing.Master);
-                if (!master.State)
-                {
-#if UNITY_EDITOR
-                    LogUtil.Warning($"当前视图{closing.Name}已被{master.Name}所关联，而{master.Name}未被打开，因此无法进行关闭操作");
-#endif
-                    return;
-                }
-            }
-
-            //4.当前关闭的视图是否被其它视图关联，是==> 如果该视图是master，则关闭所有关联了它的视图
-            if (closing.IsMaster)
-            {
-                using (var view = GetAllView().GetEnumerator())
-                {
-                    while (view.MoveNext())
-                    {
-                        if (view.Current.Master == closing.Name)
-                        {
-                            Close(view.Current.Name);
-                        }
-                    }
-                }
-            }
-
-            //5.设置状态
+            //3.设置状态
             IsRouterCtrl = true;
 
-            //6.关闭视图
+            //4.关闭视图
             closing.Close();
 
-            //7.执行回调
+            //5.执行回调
             _audioEffectCtr?.AfterClose(viewName);
 
-            //8.设置状态
+            //6.设置状态
             IsRouterCtrl = false;
         }
 
@@ -294,7 +235,7 @@ public void Close(string viewName)
         /// 获取当前最新被打开的视图
         /// </summary>
         /// <returns>最新被打开的视图名称</returns>
-        public string CurrentOpenedView()
+        private string CurrentOpenedView()
         {
             if (_histories.Count > 0)
             {
@@ -309,8 +250,8 @@ public string CurrentOpenedView()
         /// <summary>
         /// 当前最新被关闭的视图
         /// </summary>
-        /// <returns></returns>
-        public string CurrentClosedView()
+        /// <returns>最新被关闭的视图</returns>
+        private string CurrentClosedView()
         {
             if (_histories.Count > 0)
             {
diff --git a/UniVue/Runtime/View/Views/BaseView.cs b/UniVue/Runtime/View/Views/BaseView.cs
index 47a0105..a69f689 100644
--- a/UniVue/Runtime/View/Views/BaseView.cs
+++ b/UniVue/Runtime/View/Views/BaseView.cs
@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 using UniVue.Input;
 using UniVue.Model;
 using UniVue.Tween;
@@ -13,8 +12,6 @@ public class BaseView : IView
         private bool _isClosing;
         private bool _isOpening;
 
-        public int Order { get; set; }
-
         public ViewLevel Level { get; private set; }
 
         public string Name { get; private set; }
@@ -23,15 +20,7 @@ public class BaseView : IView
 
         public GameObject ViewObject { get; private set; }
 
-        public bool IsMaster { get; set; }
-
-        public string Root { get; set; }
-
-        public string Master { get; set; }
-
-        public bool Forbid { get; set; }
-
-        public IView[] nestedViews { get; set; }
+        public string Parent { get; set; }
 
         /// <summary>
         /// ViewLevel.Transient视图显示时间
@@ -59,11 +48,10 @@ public class BaseView : IView
         public float closeDuration { get; set; } = -1;
 
 
-        public BaseView(GameObject viewObject, string viewName = null, ViewLevel level = ViewLevel.Common)
+        public BaseView(GameObject viewObject, ViewLevel level = ViewLevel.Common)
         {
             this.ViewObject = viewObject;
-            if (viewName == null) { viewName = viewObject.name; }
-            Name = viewName;
+            Name = viewObject.name;
             this.Level = level;
             State = viewObject.activeSelf || level == ViewLevel.Permanent;
             ViewUtil.SetActive(viewObject, State);
@@ -77,42 +65,25 @@ public BaseView(GameObject viewObject, string viewName = null, ViewLevel level =
         /// </summary>
         public virtual void OnLoad()
         {
-            BindEvent();
+            ViewUtil.Patch2Pass(ViewObject);
         }
 
-        protected void BindEvent(params GameObject[] exclued)
-        {
-            ViewUtil.Patch2Pass(ViewObject, this, exclued);
-        }
-
-        public IView BindModel<T>(T model, bool allowUIUpdateModel = true, string modelName = null, bool forceRebind = false) where T : IBindableModel
+        public IView BindModel(IBindableModel model, bool allowUIUpdateModel = true, string modelName = null, bool forceRebind = false)
         {
             ViewUtil.BindModel(this, model, allowUIUpdateModel, modelName, forceRebind);
             return this;
         }
 
-        public void RebindModel<T>(T newModel, T oldModel) where T : IBindableModel
+        public void RebindModel(IBindableModel newModel, IBindableModel oldModel)
         {
             Vue.Updater.Rebind(Name, newModel, oldModel);
         }
 
-        public void RebindModel<T>(T newModel) where T : IBindableModel
+        public void RebindModel(IBindableModel newModel)
         {
             Vue.Updater.Rebind(Name, newModel);
         }
 
-        public IEnumerable<IView> GetNestedViews()
-        {
-            IView[] views = nestedViews;
-            if (views != null)
-            {
-                for (int i = 0; i < views.Length; i++)
-                {
-                    if (views[i] != null) { yield return views[i]; }
-                }
-            }
-        }
-
         /// <summary>
         /// 设置当前视图的拖拽配置信息
         /// </summary>
@@ -135,9 +106,7 @@ public virtual void Open()
         {
             if (!Vue.Router.IsRouterCtrl)
             {
-#if UNITY_EDITOR
-                LogUtil.Warning("所有视图的打开关闭必须通过ViewRouter对象来控制!");
-#endif
+                Vue.Router.Open(Name);
                 return;
             }
 
@@ -169,9 +138,7 @@ public virtual void Close()
         {
             if (!Vue.Router.IsRouterCtrl)
             {
-#if UNITY_EDITOR
-                LogUtil.Warning("所有视图的打开关闭必须通过ViewRouter对象来控制!");
-#endif
+                Vue.Router.Close(Name);
                 return;
             }
 
diff --git a/UniVue/Runtime/View/Views/ClampListView.cs b/UniVue/Runtime/View/Views/ClampListView.cs
index d00adc5..c88697b 100644
--- a/UniVue/Runtime/View/Views/ClampListView.cs
+++ b/UniVue/Runtime/View/Views/ClampListView.cs
@@ -11,16 +11,11 @@ public sealed class ClampListView : BaseView
     {
         private ClampList _comp;
 
-        public ClampListView(ClampList comp, GameObject viewObject, string viewName = null, ViewLevel level = ViewLevel.Common) : base(viewObject, viewName, level)
+        public ClampListView(ClampList comp, GameObject viewObject, ViewLevel level = ViewLevel.Common) : base(viewObject, level)
         {
             _comp = comp;
         }
 
-        public override void OnLoad()
-        {
-            BindEvent(_comp.Content.gameObject);
-        }
-
         public override void OnUnload()
         {
             _comp.Destroy();
diff --git a/UniVue/Runtime/View/Views/EnsureTipView.cs b/UniVue/Runtime/View/Views/EnsureTipView.cs
index 0cf2b12..c527f4b 100644
--- a/UniVue/Runtime/View/Views/EnsureTipView.cs
+++ b/UniVue/Runtime/View/Views/EnsureTipView.cs
@@ -8,7 +8,7 @@ public sealed class EnsureTipView : BaseView
     {
         private EnsureTip _comp;
 
-        public EnsureTipView(EnsureTip tipComp, GameObject viewObject, string viewName = null, ViewLevel level = ViewLevel.Common) : base(viewObject, viewName, level)
+        public EnsureTipView(EnsureTip tipComp, GameObject viewObject, ViewLevel level = ViewLevel.Common) : base(viewObject, level)
         {
             _comp = tipComp;
         }
diff --git a/UniVue/Runtime/View/Views/GridView.cs b/UniVue/Runtime/View/Views/GridView.cs
index e84b253..98f11b8 100644
--- a/UniVue/Runtime/View/Views/GridView.cs
+++ b/UniVue/Runtime/View/Views/GridView.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.UI;
 using UniVue.Model;
 using UniVue.Utils;
 using UniVue.View.Widgets;
@@ -12,25 +11,11 @@ public sealed class GridView : BaseView
     {
         private LoopGrid _gridComp;
 
-        public GridView(LoopGrid gridComp, GameObject viewObject, string viewName = null, ViewLevel level = ViewLevel.Common) : base(viewObject, viewName, level)
+        public GridView(LoopGrid gridComp, GameObject viewObject, ViewLevel level = ViewLevel.Common) : base(viewObject, level)
         {
             _gridComp = gridComp;
         }
 
-        public override void OnLoad()
-        {
-            var scrollRect = ComponentFindUtil.BreadthFind<ScrollRect>(ViewObject);
-
-            if (scrollRect == null)
-            {
-                throw new Exception("viewObject身上未包含一个ScrollRect组件，该功能依赖该组件！");
-            }
-
-            //在进行查找UI组件时要排除content下面的物体（因为这下面的每个Item会作为一个单独的FlexibleView存在）
-            BindEvent(scrollRect.content.gameObject);
-        }
-
-
         public override void OnUnload()
         {
             _gridComp.Destroy();
diff --git a/UniVue/Runtime/View/Views/IView.cs b/UniVue/Runtime/View/Views/IView.cs
index 5e2eec6..f6be23f 100644
--- a/UniVue/Runtime/View/Views/IView.cs
+++ b/UniVue/Runtime/View/Views/IView.cs
@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 using UniVue.Model;
 using UniVue.View.Widgets;
 
@@ -7,12 +6,6 @@ namespace UniVue.View.Views
 {
     public interface IView
     {
-        /// <summary>
-        /// 当前视图在同一层视图的排序
-        /// </summary>
-        /// <remarks>值越大越先被渲染</remarks>
-        int Order { get; }
-
         /// <summary>
         /// 当前视图的级别
         /// </summary>
@@ -34,31 +27,9 @@ public interface IView
         GameObject ViewObject { get; }
 
         /// <summary>
-        /// 当前视图是否是属主视图
-        /// </summary>
-        bool IsMaster { get; }
-
-        /// <summary>
-        /// 获取当前嵌套视图的根视图名称
-        /// </summary>
-        string Root { get; }
-
-        /// <summary>
-        /// 获取当前视图的属主视图的名称
-        /// </summary>
-        string Master { get; }
-
-        /// <summary>
-        /// 当前视图被打开后是否禁止其它视图再打开
-        /// </summary>
-        bool Forbid { get; }
-
-        /// <summary>
-        /// 获取此时图嵌套的所有的视图
+        /// 当前视图的父视图的视图名称
         /// </summary>
-        /// <typeparam name="T">实现IView</typeparam>
-        /// <returns>此视图包含的所有嵌套视图</returns>
-        IEnumerable<IView> GetNestedViews();
+        string Parent { get; }
 
         /// <summary>
         /// 视图加载时调用
@@ -79,7 +50,7 @@ public interface IView
         /// <param name="modelName">模型名称，若为null则默认为该类型的TypeName</param>
         /// <param name="forceRebind">当已经绑定了数据时是否指示进行强制重新绑定</param>
         /// <returns>IView</returns>
-        IView BindModel<T>(T model, bool allowUIUpdateModel = true, string modelName = null, bool forceRebind = false) where T : IBindableModel;
+        IView BindModel(IBindableModel model, bool allowUIUpdateModel = true, string modelName = null, bool forceRebind = false);
 
         /// <summary>
         /// 打开视图
@@ -97,7 +68,7 @@ public interface IView
         /// </summary>
         /// <param name="newModel">新模型</param>
         /// <param name="oldModel">旧模型</param>
-        void RebindModel<T>(T newModel, T oldModel) where T : IBindableModel;
+        void RebindModel(IBindableModel newModel, IBindableModel oldModel);
 
         /// <summary>
         /// 重新绑定模型数据
@@ -105,7 +76,7 @@ public interface IView
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="newModel"></param>
-        void RebindModel<T>(T newModel) where T : IBindableModel;
+        void RebindModel(IBindableModel newModel);
 
         /// <summary>
         /// 获取视图身上挂载的组件
diff --git a/UniVue/Runtime/View/Views/ListView.cs b/UniVue/Runtime/View/Views/ListView.cs
index 0967565..14cd9dc 100644
--- a/UniVue/Runtime/View/Views/ListView.cs
+++ b/UniVue/Runtime/View/Views/ListView.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.UI;
 using UniVue.Model;
 using UniVue.Utils;
 using UniVue.View.Widgets;
@@ -14,24 +13,11 @@ public sealed class ListView : BaseView
 
         public bool Loop { get => _listComp.Loop; set => _listComp.Loop = value; }
 
-        public ListView(LoopList listComp, GameObject viewObject, string viewName = null,
-            ViewLevel level = ViewLevel.Common) : base(viewObject, viewName, level)
+        public ListView(LoopList listComp, GameObject viewObject, ViewLevel level = ViewLevel.Common) : base(viewObject, level)
         {
             _listComp = listComp;
         }
 
-        public override void OnLoad()
-        {
-            ScrollRect scrollRect = ComponentFindUtil.BreadthFind<ScrollRect>(ViewObject);
-
-            if (scrollRect == null)
-            {
-                throw new Exception("viewObject身上未包含一个ScrollRect组件，该功能依赖该组件！");
-            }
-
-            BindEvent(scrollRect.content.gameObject);
-        }
-
         public override void OnUnload()
         {
             _listComp.Destroy();
@@ -39,8 +25,6 @@ public override void OnUnload()
             base.OnUnload();
         }
 
-
-
         /// <summary>
         /// 绑定集合
         /// </summary>
diff --git a/UniVue/Runtime/View/Views/MonoView.cs b/UniVue/Runtime/View/Views/MonoView.cs
index 3e56fb5..5af31ce 100644
--- a/UniVue/Runtime/View/Views/MonoView.cs
+++ b/UniVue/Runtime/View/Views/MonoView.cs
@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 using UniVue.Model;
 using UniVue.Utils;
 using UniVue.View.Widgets;
@@ -16,29 +15,17 @@ public class MonoView : MonoBehaviour, IView
 
         private bool _state;
 
-        /// <summary>
-        /// 对于继承自MonoView的视图此属性将是无效的
-        /// </summary>
-        public int Order => 0;
-
         public ViewLevel Level => _level;
 
         public bool State => _state;
 
-        public virtual GameObject ViewObject => gameObject;
-
-        public virtual bool IsMaster => false;
-
-        public virtual string Root => null;
+        public string Name => gameObject.name;
 
-        public virtual string Master => null;
+        public GameObject ViewObject => gameObject;
 
-        public virtual bool Forbid => false;
+        public string Parent { get; set; }
 
-        public virtual string Name => gameObject.name;
-
-
-        public virtual void OnLoad()
+        private void Start()
         {
             //初始化运行时数据
             _state = gameObject.activeSelf;
@@ -47,12 +34,9 @@ public virtual void OnLoad()
             Vue.Router.AddView(this);
         }
 
-        /// <summary>
-        /// 绑定路由事件、创建UIEvent和EventArg对象
-        /// </summary>
-        protected void BindEvent(params GameObject[] exclued)
+        public virtual void OnLoad()
         {
-            ViewUtil.Patch2Pass(ViewObject, this, exclued);
+            ViewUtil.Patch2Pass(ViewObject);
         }
 
         public virtual void OnUnload()
@@ -60,43 +44,29 @@ public virtual void OnUnload()
 
         }
 
-        public IView BindModel<T>(T model, bool allowUIUpdateModel = true, string modelName = null, bool forceRebind = false) where T : IBindableModel
+        public IView BindModel(IBindableModel model, bool allowUIUpdateModel = true, string modelName = null, bool forceRebind = false)
         {
             ViewUtil.BindModel(this, model, allowUIUpdateModel, modelName, forceRebind);
             return this;
         }
 
 
-        public void RebindModel<T>(T newModel, T oldModel) where T : IBindableModel
+        public void RebindModel(IBindableModel newModel, IBindableModel oldModel)
         {
             Vue.Updater.Rebind(Name, newModel, oldModel);
         }
 
 
-        public void RebindModel<T>(T newModel) where T : IBindableModel
+        public void RebindModel(IBindableModel newModel)
         {
             Vue.Updater.Rebind(Name, newModel);
         }
 
-        /// <summary>
-        /// 获取此时图嵌套的所有的视图
-        /// </summary>
-        /// <remarks>如果此视图含有嵌套视图，务必重写此函数，否则可能会导致路由事件重复绑定、重复构建UIEvent等问题</remarks>
-        /// <typeparam name="T">实现IView</typeparam>
-        /// <returns>此视图包含的所有嵌套视图</returns>
-        public virtual IEnumerable<IView> GetNestedViews()
-        {
-            yield return null;
-        }
-
-
         public virtual void Close()
         {
             if (!Vue.Router.IsRouterCtrl)
             {
-#if UNITY_EDITOR
-                LogUtil.Warning("所有视图的打开关闭必须通过ViewRouter对象来控制!");
-#endif
+                Vue.Router.Close(Name);
                 return;
             }
 
@@ -109,9 +79,7 @@ public virtual void Open()
         {
             if (!Vue.Router.IsRouterCtrl)
             {
-#if UNITY_EDITOR
-                LogUtil.Warning("所有视图的打开关闭必须通过ViewRouter对象来控制!");
-#endif
+                Vue.Router.Open(Name);
                 return;
             }
 
diff --git a/UniVue/Runtime/View/Views/TipView.cs b/UniVue/Runtime/View/Views/TipView.cs
index 737cf20..33f8e48 100644
--- a/UniVue/Runtime/View/Views/TipView.cs
+++ b/UniVue/Runtime/View/Views/TipView.cs
@@ -7,7 +7,7 @@ public sealed class TipView : BaseView
     {
         private Tip _tipComp;
 
-        public TipView(Tip tipComp, GameObject viewObject, string viewName = null, ViewLevel level = ViewLevel.Common) : base(viewObject, viewName, level)
+        public TipView(Tip tipComp, GameObject viewObject, ViewLevel level = ViewLevel.Common) : base(viewObject, level)
         {
             _tipComp = tipComp;
         }
diff --git a/UniVue/Runtime/View/Views/Widgets/ClampList.cs b/UniVue/Runtime/View/Views/Widgets/ClampList.cs
index 0a5a06d..591b3ff 100644
--- a/UniVue/Runtime/View/Views/Widgets/ClampList.cs
+++ b/UniVue/Runtime/View/Views/Widgets/ClampList.cs
@@ -46,6 +46,7 @@ public ClampList(Transform content)
 #endif
 
             _content = content;
+            content.name = Vue.Config.SkipDescendantNodeSeparator + content.name;
         }
 
         /// <summary>
diff --git a/UniVue/Runtime/View/Views/Widgets/LoopGrid.cs b/UniVue/Runtime/View/Views/Widgets/LoopGrid.cs
index b77b6b9..4509911 100644
--- a/UniVue/Runtime/View/Views/Widgets/LoopGrid.cs
+++ b/UniVue/Runtime/View/Views/Widgets/LoopGrid.cs
@@ -55,6 +55,7 @@ public LoopGrid(ScrollRect scrollRect, int rows, int cols, float x, float y, Dir
             scrollRect.movementType = MovementType.Elastic;
             scrollRect.horizontal = scrollDir == Direction.Horizontal;
             scrollRect.vertical = scrollDir == Direction.Vertical;
+            scrollRect.content.name = Vue.Config.SkipDescendantNodeSeparator + scrollRect.content.name;
         }
 
         private IBindableModel this[int index]
diff --git a/UniVue/Runtime/View/Views/Widgets/LoopList.cs b/UniVue/Runtime/View/Views/Widgets/LoopList.cs
index 4590509..0311655 100644
--- a/UniVue/Runtime/View/Views/Widgets/LoopList.cs
+++ b/UniVue/Runtime/View/Views/Widgets/LoopList.cs
@@ -114,6 +114,7 @@ public LoopList(ScrollRect scrollRect, float distance, int viewNum, Direction sc
             scrollRect.movementType = loop ? MovementType.Unrestricted : MovementType.Elastic;
             scrollRect.horizontal = scrollDir == Direction.Horizontal;
             scrollRect.vertical = scrollDir == Direction.Vertical;
+            scrollRect.content.name = Vue.Config.SkipDescendantNodeSeparator + scrollRect.content.name;
         }
 
         /// <summary>
diff --git a/UniVue/Runtime/ViewModel/UIBundleBuilder.cs b/UniVue/Runtime/ViewModel/UIBundleBuilder.cs
index fb59279..b792801 100644
--- a/UniVue/Runtime/ViewModel/UIBundleBuilder.cs
+++ b/UniVue/Runtime/ViewModel/UIBundleBuilder.cs
@@ -17,39 +17,39 @@ public static class UIBundleBuilder
         /// <param name="model">模型对象</param>
         /// <param name="propertyUIComps">object类型是ModelFilterResult类型</param>
         /// <returns>UIBundle（可能为null）</returns>
-        public static UIBundle Build(IBindableModel model, List<object> propertyUIComps)
+        public static UIBundle Build(IBindableModel model, List<object> propertyUIComps, bool allowUIUpdateModel = true)
         {
             List<PropertyUI> propertyUIs = new List<PropertyUI>(propertyUIComps.Count);
 
-            BuildPropertyUI_Int_Toggles(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Int_Text(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Int_Slider(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Int_Input(propertyUIs, propertyUIComps);
+            BuildPropertyUI_Int_Toggles(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Int_Text(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Int_Slider(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Int_Input(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
-            BuildPropertyUI_Float_Text(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Float_Slider(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Float_Input(propertyUIs, propertyUIComps);
+            BuildPropertyUI_Float_Text(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Float_Slider(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Float_Input(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
-            BuildPropertyUI_Enum_ToggleGroup(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Enum_Text(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Enum_Input(propertyUIs, propertyUIComps);
-            BuildPropertyUI_Enum_Dropdown(propertyUIs, propertyUIComps);
+            BuildPropertyUI_Enum_ToggleGroup(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Enum_Text(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Enum_Input(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_Enum_Dropdown(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
-            BuildPropertyUI_FlagsEnum_Toggles(propertyUIs, propertyUIComps);
-            BuildPropertyUI_FlagsEnum_Text(propertyUIs, propertyUIComps);
+            BuildPropertyUI_FlagsEnum_Toggles(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_FlagsEnum_Text(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
-            BuildPropertyUI_String_Input(propertyUIs, propertyUIComps);
-            BuildPropertyUI_String_Text(propertyUIs, propertyUIComps);
+            BuildPropertyUI_String_Input(propertyUIs, propertyUIComps, allowUIUpdateModel);
+            BuildPropertyUI_String_Text(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
-            BuildPropertyUI_Bool_Toggle(propertyUIs, propertyUIComps);
+            BuildPropertyUI_Bool_Toggle(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
-            BuildPropertyUI_Sprite_Image(propertyUIs, propertyUIComps);
+            BuildPropertyUI_Sprite_Image(propertyUIs, propertyUIComps, allowUIUpdateModel);
 
             return propertyUIs.Count == 0 ? null : new UIBundle(model, propertyUIs);
         }
 
         #region Int绑定UI
-        private static void BuildPropertyUI_Int_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Int_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
@@ -60,29 +60,29 @@ private static void BuildPropertyUI_Int_Text(List<PropertyUI> propertyUIs, List<
             }
         }
 
-        private static void BuildPropertyUI_Int_Slider(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Int_Slider(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.Slider || (result.BindType != BindableType.Int && result.BindType != BindableType.ListInt)) continue;
-                propertyUIs.Add(new IntSlider(result.Component as Slider, result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new IntSlider(result.Component as Slider, result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
 
-        private static void BuildPropertyUI_Int_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Int_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.TMP_InputField || result.BindType != BindableType.Int) continue;
-                propertyUIs.Add(new IntInput(result.Component as TMP_InputField, result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new IntInput(result.Component as TMP_InputField, result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
 
-        private static void BuildPropertyUI_Int_Toggles(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Int_Toggles(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             if (propertyUIComps.Count == 0) return;
 
@@ -111,18 +111,18 @@ private static void BuildPropertyUI_Int_Toggles(List<PropertyUI> propertyUIs, Li
         #endregion
 
         #region String绑定UI
-        private static void BuildPropertyUI_String_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_String_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.TMP_InputField || result.BindType != BindableType.String) continue;
-                propertyUIs.Add(new StringInput(result.Component as TMP_InputField, result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new StringInput(result.Component as TMP_InputField, result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
 
-        private static void BuildPropertyUI_String_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_String_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
@@ -136,7 +136,7 @@ private static void BuildPropertyUI_String_Text(List<PropertyUI> propertyUIs, Li
         #endregion
 
         #region Float绑定UI
-        private static void BuildPropertyUI_Float_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Float_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
@@ -147,37 +147,37 @@ private static void BuildPropertyUI_Float_Text(List<PropertyUI> propertyUIs, Lis
             }
         }
 
-        private static void BuildPropertyUI_Float_Slider(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Float_Slider(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.Slider || (result.BindType != BindableType.Float && result.BindType != BindableType.ListFloat)) continue;
-                propertyUIs.Add(new FloatSlider(result.Component as Slider, result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new FloatSlider(result.Component as Slider, result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
 
-        private static void BuildPropertyUI_Float_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Float_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.TMP_InputField || result.BindType != BindableType.Float) continue;
-                propertyUIs.Add(new FloatInput(result.Component as TMP_InputField, result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new FloatInput(result.Component as TMP_InputField, result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
         #endregion
 
         #region Bool绑定UI
-        private static void BuildPropertyUI_Bool_Toggle(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Bool_Toggle(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.Toggle || (result.BindType != BindableType.Bool && result.BindType != BindableType.ListBool)) continue;
-                propertyUIs.Add(new BoolToggle(result.Component as Toggle, result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new BoolToggle(result.Component as Toggle, result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
@@ -186,7 +186,7 @@ private static void BuildPropertyUI_Bool_Toggle(List<PropertyUI> propertyUIs, Li
 
         #region Enum绑定UI
 
-        private static void BuildPropertyUI_Enum_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Enum_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
@@ -197,29 +197,29 @@ private static void BuildPropertyUI_Enum_Text(List<PropertyUI> propertyUIs, List
             }
         }
 
-        private static void BuildPropertyUI_Enum_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Enum_Input(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.TMP_InputField || result.BindType != BindableType.Enum || ReflectionUtil.HasFlags(result.Property.PropertyType)) continue;
-                propertyUIs.Add(new EnumInput(result.Component as TMP_InputField, Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new EnumInput(result.Component as TMP_InputField, Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
 
-        private static void BuildPropertyUI_Enum_Dropdown(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Enum_Dropdown(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
                 ModelFilterResult result = (ModelFilterResult)propertyUIComps[i];
                 if (result.UIType != UIType.TMP_Dropdown || result.BindType != BindableType.Enum || ReflectionUtil.HasFlags(result.Property.PropertyType)) continue;
-                propertyUIs.Add(new EnumDropdown(result.Component as TMP_Dropdown, Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new EnumDropdown(result.Component as TMP_Dropdown, Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 ListUtil.TrailDelete(propertyUIComps, i--);
             }
         }
 
-        private static void BuildPropertyUI_Enum_ToggleGroup(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Enum_ToggleGroup(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             if (propertyUIComps.Count == 0) return;
 
@@ -251,7 +251,7 @@ private static void BuildPropertyUI_Enum_ToggleGroup(List<PropertyUI> propertyUI
                     propertyUIComps.RemoveAt(j--); //不能采用尾删
                 }
 
-                propertyUIs.Add(new EnumToggleGroup(toggles.ToArray(), Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new EnumToggleGroup(toggles.ToArray(), Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 i--; //当前位置被删除了，因此减一
                 toggles.Clear();
             }
@@ -261,7 +261,7 @@ private static void BuildPropertyUI_Enum_ToggleGroup(List<PropertyUI> propertyUI
 
         #region FlagsEnum绑定UI
 
-        private static void BuildPropertyUI_FlagsEnum_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_FlagsEnum_Text(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
@@ -272,7 +272,7 @@ private static void BuildPropertyUI_FlagsEnum_Text(List<PropertyUI> propertyUIs,
             }
         }
 
-        private static void BuildPropertyUI_FlagsEnum_Toggles(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_FlagsEnum_Toggles(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             if (propertyUIComps.Count == 0) return;
 
@@ -304,7 +304,7 @@ private static void BuildPropertyUI_FlagsEnum_Toggles(List<PropertyUI> propertyU
                     propertyUIComps.RemoveAt(j--); //不能采用尾删
                 }
 
-                propertyUIs.Add(new FlagsEnumToggles(toggles.ToArray(), Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite));
+                propertyUIs.Add(new FlagsEnumToggles(toggles.ToArray(), Enum.GetValues(result.Property.PropertyType), result.PropertyName, result.Property.CanWrite && allowUIUpdateModel));
                 i--; //当前位置被删除了，因此减一
                 toggles.Clear();
             }
@@ -315,7 +315,7 @@ private static void BuildPropertyUI_FlagsEnum_Toggles(List<PropertyUI> propertyU
 
         #region Sprite绑定UI
 
-        private static void BuildPropertyUI_Sprite_Image(List<PropertyUI> propertyUIs, List<object> propertyUIComps)
+        private static void BuildPropertyUI_Sprite_Image(List<PropertyUI> propertyUIs, List<object> propertyUIComps, bool allowUIUpdateModel)
         {
             for (int i = 0; i < propertyUIComps.Count; i++)
             {
diff --git a/UniVue/Runtime/ViewModel/ViewUpdater.cs b/UniVue/Runtime/ViewModel/ViewUpdater.cs
index 1439ed3..7425026 100644
--- a/UniVue/Runtime/ViewModel/ViewUpdater.cs
+++ b/UniVue/Runtime/ViewModel/ViewUpdater.cs
@@ -227,7 +227,7 @@ public void UpdateUI(string viewName, string propertyName, List<Sprite> property
         }
 
 
-        private void UpdateUI<T>(string propertyName, string viewName, T consumer) where T : IConsumableModel
+        private void UpdateUI(string propertyName, string viewName, IConsumableModel consumer)
         {
             if (Table.TryGetBundles(viewName, out List<UIBundle> bundles))
             {
@@ -239,7 +239,7 @@ private void UpdateUI<T>(string propertyName, string viewName, T consumer) where
         }
 
 
-        private void UpdateUI<T>(string viewName, T consumer) where T : IConsumableModel
+        private void UpdateUI(string viewName, IConsumableModel consumer)
         {
             if (Table.TryGetBundles(viewName, out List<UIBundle> bundles))
             {
@@ -266,7 +266,7 @@ public void UnloadBundle(string viewName)
         /// <param name="viewName">需要重新绑定模型的视图名称</param>
         /// <param name="newModel">新模型</param>
         /// <param name="oldModel">旧模型</param>
-        public void Rebind<T>(string viewName, T newModel, T oldModel) where T : IBindableModel
+        public void Rebind(string viewName, IBindableModel newModel, IBindableModel oldModel)
         {
             Table.Rebind(viewName, oldModel, newModel);
         }
@@ -276,7 +276,7 @@ public void Rebind<T>(string viewName, T newModel, T oldModel) where T : IBindab
         /// </summary>
         /// <param name="viewName">需要重新绑定模型的视图名称</param>
         /// <param name="newModel">新模型</param>
-        public void Rebind<T>(string viewName, T newModel) where T : IBindableModel
+        public void Rebind(string viewName, IBindableModel newModel)
         {
             Table.Rebind(viewName, newModel);
         }
@@ -286,9 +286,8 @@ public void Rebind<T>(string viewName, T newModel) where T : IBindableModel
         ///  解除此模型与所有它绑定的视图的关系
         /// </summary>
         /// <remarks>实际上不会销毁已经创建的UIBundle对象，只是将其设置为失活状态。处于失活状态时无法进行UI更新以及通过UI更新模型</remarks>
-        /// <typeparam name="T"></typeparam>
         /// <param name="model">要解绑的模型</param>
-        public void Unbind<T>(T model) where T : IBindableModel
+        public void Unbind(IBindableModel model)
         {
             Table.Unbind(model);
         }