string testresourceurl = "*/HotUpdate.apk";
var webrequest = UnityWebRequest.Get(testresourceurl);
yield return webrequest.SendWebRequest();
if (webrequest.isNetworkError)
{
    Debug.LogError(string.Format("{0}安装包下载出错!", testresourceurl));
    Debug.LogError(webrequest.error);
    if (webrequest.isHttpError)
    {
        Debug.LogError(string.Format("responseCode : ", webrequest.responseCode));
    }
}
else
{
    Debug.Log(string.Format("{0} webrequest.isDone:{1}!", testresourceurl, webrequest.isDone));
    Debug.Log(string.Format("{0}安装包下载完成!", testresourceurl));
    var downloadfilefolderpath = Application.persistentDataPath + "/download/";
    var downloadfilesavepath = downloadfilefolderpath + "app.apk";
    Debug.Log("downloadfilefolderpath = " + downloadfilefolderpath);
    Debug.Log("downloadfilesavepath = " + downloadfilesavepath);
    if(!Directory.Exists(downloadfilefolderpath))
    {
        Directory.CreateDirectory(downloadfilefolderpath);
    }
    if (File.Exists(downloadfilesavepath))
    {
        File.Delete(downloadfilesavepath);
    }
    using (var fs = File.Create(downloadfilesavepath))
    {
        fs.Write(webrequest.downloadHandler.data, 0, webrequest.downloadHandler.data.Length);
        fs.Flush();
        fs.Close();
        Debug.Log(downloadfilesavepath + "文件写入完成!");
    }
}

Application.OpenURL("itms-apps://itunes.apple.com/app/id" + appID);

Application.OpenURL("market://details?id=" + appID);

ManifestFileVersion: 0
CRC: 961902239
AssetBundleManifest:
  AssetBundleInfos:
    Info_0:
      Name: nonuiprefabs/nui_capsulesingletexture
      Dependencies:
        Dependency_0: materials/mt_singletexturematerial
    Info_1:
      Name: shaders/sd_shaderlist
      Dependencies: {}
    Info_2:
      Name: materials/mt_singletexturematerial
      Dependencies:
        Dependency_0: shaders/sd_shaderlist
        Dependency_1: textures/tx_brick_diffuse
    Info_3:
      Name: textures/tx_brick_diffuse
      Dependencies: {}
    Info_4:
      Name: nonuiprefabs/nui_capsulenormalmappingtexture
      Dependencies: {}
    Info_5:
      Name: textures/tx_brick_normal
      Dependencies: {}
    Info_6:
      Name: materials/mt_normalmappingmaterial
      Dependencies:
        Dependency_0: shaders/sd_shaderlist
        Dependency_1: textures/tx_brick_diffuse
        Dependency_2: textures/tx_brick_normal

Object[] assetsselections = Selection.GetFiltered(Type, SelectionMode);

// 获取选中Asset的路径
assetpath = AssetDatabase.GetAssetPath(assetsselections[i]);
// 获取选中Asset的GUID
assetguid = AssetDatabase.AssetPathToGUID(assetpath);

// 获取指定Asset的Asset设置接口
AssetImporter assetimporter = AssetImporter.GetAtPath(assetpath);
// 设置Asset的AB信息
assetimporter.assetBundleVariant = ABVariantName;
assetimporter.assetBundleName = ABName;

BuildPipeline.BuildAssetBundles(outputPath, BuildAssetBundleOptions, BuildTarget); 

BuildPipeline.BuildAssetBundles(string outputPath, AssetBundleBuild[] builds, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform);

// 加载本地压缩过的AB
AssetBundle.LoadFromFile(abfullpath)
// 加载AB里的指定Asset
AssetBundle.LoadAsset(assetname);
// 加载AB里的所有Asset
AssetBundle.LoadAllAssets();

// 回收AssetBundle并连带加载实例化出来的Asset以及GameObject一起回收
AssetBundle.Unload(true);
// 只回收AssetBundle
AssetBundle.Unload(false);

// 回收指定Asset(这里的Asset不能为GameObject)
Resource.UnloadAsset(asset);
// 回收内存以所有不再有任何引用的Asset
Resources.UnloadUnusedAssets();

// 内存回收
GC.Collect();

nonuiprefabab = loadAssetBundle(abfullname);
var nonuiprefabasset = loadMainAsset(nonuiprefabab);
nonuigo = GameObject.Instantiate(nonuiprefabasset) as GameObject;
// Asest一旦加载进来，我们就可以进行缓存，相应的AB就可以释放掉了
// 后续会讲到相关AB和Asset释放API
nonuiprefabab.Unload(false);

NonUIPrefabDepInfo nonuidpinfo = nonuigo.GetComponent<NonUIPrefabDepInfo>();
var dpmaterials = nonuidpinfo.mDPMaterialInfoList;
for (int i = 0; i < dpmaterials.Count; i++)
{
    for(int j = 0; j < dpmaterials[i].mMaterialNameList.Count; j++)
    {
        MaterialResourceLoader.getInstance().addMaterial(dpmaterials[i].mRenderer, dpmaterials[i].mMaterialNameList[j]);
    }
}

// 根据材质_InfoAsset.asset进行还原材质原始Shader以及Texture信息
var materialinfoasseetname = string.Format("{0}_{1}InfoAsset.asset", materialname, ResourceHelper.CurrentPlatformPostfix);
var materialassetinfo = loadSpecificAsset(materialab, materialinfoasseetname.ToLower()) as MaterialAssetInfo;
// 加载材质依赖的Shader
var materialshader = materialassetinfo.mShaderName;
var shader = ShaderResourceLoader.getInstance().getSpecificShader(materialshader);
material.shader = shader;

// 获取Shader使用的Texture信息进行还原
var materialdptextureinfo = materialassetinfo.mTextureInfoList;
for (int i = 0; i < materialdptextureinfo.Count; i++)
{
    // 加载指定依赖纹理
    Texture shadertexture = TextureResourceLoader.getInstance().loadTexture(materialdptextureinfo[i].Value);
    //设置材质的对应Texture
    material.SetTexture(materialdptextureinfo[i].Key, shadertexture);
}

Resources.UnloadAsset(materialasset);

mNonUIPrefabAssetMap = null;

foreach(var texture in mTexturesUsingMap)
{
    unloadAsset(texture.Value);
}
mTexturesUsingMap = null;

Resources.UnloadUnusedAssets();

/// <summary>
/// 测试异步转同步窗口加载
/// </summary>
public void onAsynToSyncLoadWindow()
{
    DIYLog.Log("onAsynToSyncLoadWindow()");
    if (mMainWindow == null)
    {
        onDestroyWindowInstance();
    }
    AssetLoader assetLoader;
    var requestUID = ResourceManager.Singleton.getPrefabInstanceAsync(
        "Assets/Res/windows/MainWindow.prefab",
        out assetLoader,
        (prefabInstance, requestUid) =>
        {
            mMainWindow = prefabInstance;
            mMainWindow.transform.SetParent(UIRootCanvas.transform, false);
        }
    );
    // 将异步转同步加载
    assetLoader.loadImmediately();
}

/// <summary>
/// 销毁窗口实例对象
/// </summary>
public void onDestroyWindowInstance()
{
    DIYLog.Log("onDestroyWindowInstance()");
    GameObject.Destroy(mMainWindow);
}

/// <summary>
/// 加载常驻Shader
/// </summary>
public void onLoadPermanentShaderList()
{
    DIYLog.Log("onLoadPermanentShaderList()");
    ResourceManager.Singleton.loadAllShader("shaderlist", () =>
    {
    },
    ResourceLoadType.PermanentLoad);
}

/// <summary>
/// 执行新版Scriptable Build Pipeline AB打包
/// </summary>
/// <param name="outputDirectory"></param>
/// <param name="buildSuccess"></param>
private void DoSBPAssetBundleBuild(string outputDirectory, out bool buildSuccess)
{
    var buildParams = MakeBuildParameters();
    IBundleBuildResults results;
    SBPAssetBundleBuilder.BuildAllAssetBundles(this, outputDirectory, BuildTarget, buildParams, mAllAssetBundleBuildList, out buildSuccess, out results);
    CreateSBPReadmeFile(outputDirectory, results);
}

/// <summary>
/// 获取构建参数
/// </summary>
private CustomBuildParameters MakeBuildParameters()
{
    CustomBuildParameters bundleBuildParameters = new CustomBuildParameters(BuildTarget, BuildTargetGroup, OutputDirectory);
    //bundleBuildParameters.CacheServerHost = "";
    //bundleBuildParameters.CacheServerPort = ;
    bundleBuildParameters.BundleCompression = GetConfigBuildCompression();
    if (IsForceRebuild)
    {
        // 是否增量打包
        bundleBuildParameters.UseCache = !IsForceRebuild;
    }
    bundleBuildParameters.ContiguousBundles = true;
    if (IsAppendHash)
    {
        bundleBuildParameters.AppendHash = IsAppendHash;
    }
    if (IsDisableWriteTypeTree)
    {
        bundleBuildParameters.ContentBuildFlags |= ContentBuildFlags.DisableWriteTypeTree;
    }
    bundleBuildParameters.ContentBuildFlags |= ContentBuildFlags.StripUnityVersion;
    if (IsIgnoreTypeTreeChanges)
    {
        // SBP不支持BuildAssetBundleOptions.IgnoreTypeTreeChanges
    }
    // 添加自定义AB压缩格式设置
    foreach(var assetBundleBuildInfo in mAllAssetBundleBuildInfoList)
    {
        bundleBuildParameters.AddAssetBundleCompression(assetBundleBuildInfo.AssetBundleName, assetBundleBuildInfo.Compression);
    }
    return bundleBuildParameters;
}

/// <summary>
/// 执行新版Scriptable Build Pipeline自定义AB打包
/// </summary>
/// <param name="assetBundleBuilder">AB打包工具</param>
/// <param name="outputDirectory">输出目录</param>
/// <param name="buildTarget">打包平台</param>
/// <param name="options">打包选项设置</param>
/// <param name="allAssetBundleBuildList">AB打包列表</param>
/// <param name="buildSuccess">打包是否成功</param>
/// <param name="results">打包结果</param>
/// <returns></returns>
public static CompatibilityAssetBundleManifest BuildAllAssetBundles(AssetBundleBuilder assetBundleBuilder, string outputDirectory, BuildTarget buildTarget, CustomBuildParameters buildParams, List<AssetBundleBuild> allAssetBundleBuildList, out bool buildSuccess, out IBundleBuildResults results)
{
    ScriptableBuildPipeline.slimWriteResults = true;
    ScriptableBuildPipeline.useDetailedBuildLog = false;
    ScriptableBuildPipeline.threadedArchiving = true;
    var buildContent = new BundleBuildContent(allAssetBundleBuildList);
    ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results);
    buildSuccess = exitCode >= ReturnCode.Success;
    if (exitCode < ReturnCode.Success)
    {
        Debug.LogError($"[BuildPatch] 构建过程中发生错误exitCode:{exitCode}！");
        return null;
    }
    CompatibilityAssetBundleManifest unityManifest = CreateAndBuildAssetBundleManifest(assetBundleBuilder, outputDirectory, buildParams, results, out buildSuccess);
    CheckCycleDependSBP(unityManifest);
    return unityManifest;
}

/// <summary>
/// 创建并打包AssetBundleManifest
/// Note:
/// 1. 新版Scriptable Build Pipeline打包没有AssetBundleManifest文件，需要自己创建并打包CompatibilityAssetBundleManifest兼容文件
/// </summary>
/// <param name="assetBundleBuilder">AB打包工具</param>
/// <param name="outputDirectory">输出目录</param>
/// <param name="buildParams">打包参数</param>
/// <param name="results">打包结果</param>
/// <param name="buildSuccess">打包是否成功</param>
/// <returns></returns>
private static CompatibilityAssetBundleManifest CreateAndBuildAssetBundleManifest(AssetBundleBuilder assetBundleBuilder, string outputDirectory, CustomBuildParameters buildParams, IBundleBuildResults results, out bool buildSuccess)
{
    var outputDirectoryFullPath = Path.GetFullPath(outputDirectory);
    var outputDirectoryInfo = new DirectoryInfo(outputDirectoryFullPath);
    var manifestName = outputDirectoryInfo.Name;
    var manifest = ScriptableObject.CreateInstance<CompatibilityAssetBundleManifest>();
    manifest.SetResults(results.BundleInfos);
    var manifestPath = buildParams.GetOutputFilePathForIdentifier($"{manifestName}.manifest");
    Debug.Log($"manifestPath:{manifestPath}");
    var manifestAssetFolderPath = $"Assets/SBPBuildManifest/{buildParams.Target}";
    if(!Directory.Exists(manifestAssetFolderPath))
    {
        Directory.CreateDirectory(manifestAssetFolderPath);
    }
    var manifestAssetFilePath = Path.Combine(manifestAssetFolderPath, $"{manifestName}.asset");
    AssetDatabase.CreateAsset(manifest, manifestAssetFilePath);
    AssetDatabase.SaveAssets();
    AssetDatabase.Refresh();
    var buildContent = new BundleBuildContent(new[]
                                              {
                                                  new AssetBundleBuild()
                                                  {
                                                      assetBundleName = manifestName,
                                                      assetBundleVariant = assetBundleBuilder.GetAssetBuildBundleVariant(manifestAssetFilePath),
                                                      assetNames = new[] { manifestAssetFilePath },
                                                      // Manifest的Asset名强制用固定名字
                                                      addressableNames = new[] { ResourceConstData.AssetBundleManifestAssetName },
                                                  }
                                              });
    var exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out _);
    buildSuccess = exitCode >= ReturnCode.Success;
    if(exitCode < ReturnCode.Success)
    {
        Debug.LogError($"打包AssetBundleManifest失败！eixtCode:{exitCode}");
        return null;
    }
    Debug.Log($"AB的Manifest打包成功！");
    return manifest;
}

void InputHandler::handleInput()
{
    if(Input.GetKeyDown(KEY_A))
    {
        Attack();
    }
    else if(Input.GetKeyDown(KEY_SPACE))
    {
        Jump();        
    }
}

public absctract class Command
{
    public abstract void execute();
}

public class AttackCommand : Command
{
    public override void execute()
    {
        Attack();
    }    
}

public class JumpCommand : Command
{
    public override void execute()
    {
        Jump();
    }    
}

public class InputHandler
{
    private Command Key_A;
    private Command Key_Space;

    // 绑定命令的方法(用于支持动态修改按钮行为绑定)
    // **********

    public void handleInput()
    {
        if(Input.GetKeyDown(KEY_A))
        {
            Key_A.execute();
        }
        else if(Input.GetKeyDown(KEY_SPACE))
        {
            Key_Space.execute();
        }
    }
}

public abstract class Command
{
    public abstract void execute(GameActor actor);
};

public class JumpCommand : Command
{
    public override void execute(GameActor actor)
    {
        actor.Jump();
    }    
}

Command* command = inputHandler.handleInput();
if (command)
{
    command->execute(actor);
}

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

/// <summary>
/// 监听者模式的监听者接口
/// </summary>
public interface ObserverBase {

    /// <summary>
    /// 用于更新监听者状态
    /// </summary>
    /// <param name="subject"></param>
    void update(SubjectBase subject);
}

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

/// <summary>
/// 监听者模式，发布者父类
/// </summary>
public class SubjectBase {

    /// <summary>
    /// 监听者列表
    /// </summary>
    private List<ObserverBase> mObserverList;

    public SubjectBase()
    {
        mObserverList = new List<ObserverBase>();
    }

    /// <summary> 添加监听者 /// </summary>
    /// <param name="observer"></param>
    public virtual void addObserver(ObserverBase observer)
    {
        mObserverList.Add(observer);
    }

    /// <summary> 删除监听者 /// </summary>
    /// <param name="observer"></param>
    public virtual void deleteObserver(ObserverBase observer)
    {
        mObserverList.Remove(observer);
    }

    /// <summary> 通知所有监听者 /// </summary>
    public virtual void notifyAllObserver()
    {
        foreach(var obesrver in mObserverList)
        {
            obesrver.update(this);
        }
    }
}

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

/// <summary>
/// MVC中的View，负责UI显示
/// </summary>
public class UIView : MonoBehaviour, ObserverBase {

    public Text mTxtRandomNumber;

    public Button mBtnRandomNumber;

    // Use this for initialization
    void Start () {
        // 添加UIController对UI点击事件的响应
        mBtnRandomNumber.onClick.AddListener(UIController.Instance.OnBtnRandomNumberClick);
    }

    public void update(SubjectBase subject)
    {
        // View层被通知监听对象改变了
        // 这里是UIModel改变了
        refreshView(subject);
    }

    /// <summary>
    /// 刷新视图显示
    /// </summary>
    private void refreshView(SubjectBase subject)
    {
        // 获取UIModel数据刷新显示
        var uimodel = subject as UIModel;
        mTxtRandomNumber.text = uimodel.mRandomNumber.ToString();
    }
}

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

/// <summary>
/// MVC里的Model，负责存储随机数数据
/// </summary>
public class UIModel : SubjectBase {

    public static UIModel Instance
    {
        get
        {
            if (mInstance == null)
            {
                mInstance = new UIModel();
            }
            return mInstance;
        }
    }
    private static UIModel mInstance;

    /// <summary>
    /// 随机数数据
    /// </summary>
    public int mRandomNumber;

    /// <summary>
    /// 随机一个数字
    /// </summary>
    public void randomNumber()
    {
        mRandomNumber = Random.Range(0, 100);
        // 通知UIView更新显示
        notifyAllObserver();
    }
}

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

/// <summary>
/// MVC中的Controller，负责连接(解耦)模型和视图，如处理视图的请求，更新模型数据，通知视图变化等
/// 逻辑部分都在这里
/// </summary>
public class UIController {
    
    public static UIController Instance
    {
        get
        {
            if(mInstance == null)
            {
                mInstance = new UIController();
            }
            return mInstance;
        }
    }
    private static UIController mInstance;

    private UIController()
    {

    }

    /// <summary>
    /// UIView按钮点击事件响应
    /// </summary>
    public void OnBtnRandomNumberClick()
    {
        // 响应UIView按钮点击，
        // 修改UIModel数据，
        UIModel.Instance.randomNumber();
    }
}

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

public class GameProgrammingPattern : MonoBehaviour {

    /// <summary> MVC里的模型 /// </summary>
    private UIModel mModel;

    /// <summary> MVC里的视图 /// </summary>
    private UIView mView;

    void Awake()
    {
        // 初始化MVC里的各个模块
        mModel = UIModel.Instance;
        mView = this.transform.GetComponentInChildren<UIView>();
    }

    void Start ()
    {
        // 添加UIView对UIModel的监听
        mModel.addObserver(mView);
    }
}

/*
 * Description:             BindableProperty.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/15
 */

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

/// <summary>
/// BindableProperty.cs
/// 可触发回调的属性抽象
/// </summary>
public class BindableProperty<T> {
    
    /// <summary>
    /// 属性值变化回调委托定义
    /// </summary>
    /// <param name="oldvalue"></param>
    /// <param name="newvalue"></param>
    public delegate void ValueChangedDelegate(T oldvalue, T newvalue);

    /// <summary>
    /// 属性值变化回调
    /// </summary>
    public ValueChangedDelegate OnValueChanged;

    /// <summary>
    /// 属性
    /// </summary>
    public T Value
    {
        get
        {
            return mValue;
        }
        set
        {
            T oldvalue = mValue;
            mValue = value;
            ValueChanged(oldvalue, mValue);
        }
    }
    private T mValue;

    /// <summary>
    /// 属性值变化时
    /// </summary>
    /// <param name="oldvalue"></param>
    /// <param name="newvalue"></param>
    private void ValueChanged(T oldvalue, T newvalue)
    {
        if(OnValueChanged != null)
        {
            OnValueChanged(oldvalue, newvalue);
        }
    }
}

public readonly BindableProperty<string> Name = new BindableProperty<string>();
public readonly BindableProperty<int> AgeDetail = new BindableProperty<int>();

/*
 * Description:             MVVMViewModel.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/15
 */

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

/// <summary>
/// MVVMViewModel.cs
/// MVVM里的VM
/// </summary>
public class MVVMViewModel {

    /// <summary> 与View里Name绑定的名字属性 /// </summary>
    public readonly BindableProperty<string> Name = new BindableProperty<string>();

    /// <summary> 与View里Age绑定的年纪属性 /// </summary>
    public readonly BindableProperty<int> Age = new BindableProperty<int>();

    /// <summary> Model数据 /// </summary>
    private MVVMModel Model;

    /// <summary>
    /// 初始化Model数据
    /// </summary>
    /// <param name="m"></param>
    public void initializeModel(MVVMModel m)
    {
        Model = m;
        Name.Value = Model.Name;
        Age.Value = Model.Age;
    }

    /// <summary>
    /// 保存Model数据
    /// </summary>
    public void saveModel()
    {
        Model.Name = Name.Value;
        Model.Age = Age.Value;
    }
}

/*
 * Description:             MVVMView.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/15
 */

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

/// <summary>
/// MVVMView.cs
/// MVVM里的View
/// </summary>
public class MVVMView : MonoBehaviour {

    /// <summary> Name输入文本(用于View输入改变Name) /// </summary>
    public InputField mInputFieldName;

    /// <summary> Name值展示文本 /// </summary>
    public Text mTxtName;
    
    /// <summary> Age值展示文本 /// </summary>
    public Text mTxtAge;

    /// <summary> Model数据保存按钮 /// </summary>
    public Button mBtnSave;

    /// <summary> View所绑定的ViewModel /// </summary>
    private MVVMViewModel mViewModel;

    /// <summary>
    /// 绑定V到指定VM
    /// </summary>
    /// <param name="vm"></param>
    public void bindViewModel(MVVMViewModel vm)
    {
        mViewModel = vm;
    }

    /// <summary>
    /// 初始化View(主要是V到VM之间的绑定)
    /// </summary>
    public void initialize()
    {
        #region Bind VM to V Part
        mViewModel.Name.OnValueChanged = onNameChanged;
        mViewModel.Age.OnValueChanged = onAgeChanged;
        #endregion

        #region Bind V To VM
        mInputFieldName.onValueChanged.AddListener(onInputNameChanged);
        mBtnSave.onClick.AddListener(onSaveClick);
        #endregion
    }

    #region Bind VM to V Part
    private void onNameChanged(string oldname, string newname)
    {
        mInputFieldName.text = newname;
        mTxtName.text = newname;
    }

    private void onAgeChanged(int oldvalue, int newvalue)
    {
        mTxtAge.text = newvalue.ToString();
    }
    #endregion

    #region Bind V To VM
    private void onInputNameChanged(string newname)
    {
        mViewModel.Name.Value = newname;
    }

    private void onSaveClick()
    {
        mViewModel.saveModel();
    }
    #endregion
}

/*
 * Description:             MVVMModel.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/15
 */

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

/// <summary>
/// MVVMModel.cs
/// MVVM里的Model
/// </summary>
public class MVVMModel {

    /// <summary> 名字 /// </summary>
    public string Name { get; set; }

    /// <summary> 年纪 /// </summary>
    public int Age { get; set; }

    public MVVMModel()
    {
        Name = "TonyTang";
        Age = 28;
    }
}

/*
 * Description:             GameProgrammingPattern.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/15
 */

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

public class GameProgrammingPattern : MonoBehaviour {

    #region MVC Part
    /// <summary> MVC里的模型 /// </summary>
    private UIModel mModel;

    /// <summary> MVC里的视图 /// </summary>
    private UIView mView;
    #endregion

    #region MVVM Part
    /// <summary> MVVM里的模型M /// </summary>
    private MVVMModel mMVVMModel;

    /// <summary> MVVM里的视图V /// </summary>
    private MVVMView mMVVMView;

    /// <summary> MVVM里的视图VM /// </summary>
    private MVVMViewModel mMVVMViewModel;

    /// <summary> 动态变化Age属性值频率 /// </summary>
    private WaitForSeconds mAgeChangeFrequency;
    #endregion

    void Awake()
    {
        initMonoScripts();

        #region MVC Part
        // 初始化MVC里的各个模块
        mModel = UIModel.Instance;
        mView = this.transform.GetComponentInChildren<UIView>();
        #endregion

        #region MVVM Part
        mMVVMViewModel = new MVVMViewModel();
        mMVVMModel = new MVVMModel();
        mMVVMView = this.transform.GetComponentInChildren<MVVMView>();

        mAgeChangeFrequency = new WaitForSeconds(5.0f);
        #endregion
    }

    void Start ()
    {
        #region MVC Part
        // 添加UIView对UIModel的监听
        mModel.addObserver(mView);
        #endregion

        #region MVVM Part
        // 初始化ViewModel里的Model数据
        mMVVMViewModel.initializeModel(mMVVMModel);
        // 绑定View到VM上
        mMVVMView.bindViewModel(mMVVMViewModel);
        // 初始化View和ViewModel的双向绑定
        mMVVMView.initialize();
        // 通过携程动态使用VM修改值Age触发View变化显示
        CoroutineManager.Singleton.startCoroutine(changeViewModelAgeCoroutine());
        #endregion
    }

    /// <summary>
    /// 初始化需要挂在的脚本
    /// </summary>
    private void initMonoScripts()
    {
        this.gameObject.AddComponent<CoroutineManager>();
    }

    /// <summary>
    /// 修改ViewModel的Age属性值携程
    /// </summary>
    /// <returns></returns>
    IEnumerator changeViewModelAgeCoroutine()
    {
        while(true)
        {
            yield return mAgeChangeFrequency;
            mMVVMViewModel.Age.Value = Random.Range(0, 100);
        }
    }
}

/*
 * Description:             IMVVMView.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/16
 */

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

/// <summary>
/// IMVVMView.cs
/// MVVM里的V的抽象接口(抽象出V和VM之间的绑定关系)
/// </summary>
public interface IMVVMView {

    /// <summary>
    /// MVVM里V的VM上下文
    /// Note:
    /// 通过定义VM的Interface接口类成员，实现依赖倒置
    /// </summary>
    IMVVMViewModel mMVVMViewModelContext
    {
        get;
        set;
    }
}

/*
 * Description:             IMVVMViewModel.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/16
 */

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

/// <summary>
/// IMVVMViewModel.cs
/// MVVM里的VM抽象接口(实现依赖倒置，避免V和VM的高度耦合)
/// </summary>
public interface IMVVMViewModel {


}

/*
 * Description:             MVVMBaseView.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/16
 */

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

/// <summary>
/// MVVMBaseView.cs
/// MVVM里的View的基类(含ViewModel的动态绑定定义以及ViewModel的接口成员定义(依赖倒置))
/// </summary>
public class MVVMBaseView : MonoBehaviour, IMVVMView
{
    /// <summary>
    /// 可绑定的ViewModel属性
    /// 用于实现V动态绑定VM
    /// </summary>
    protected readonly BindableProperty<IMVVMViewModel> ViewModelProperty = new BindableProperty<IMVVMViewModel>();

    /// <summary>
    /// V的VM上下文属性接口
    /// </summary>
    public IMVVMViewModel mMVVMViewModelContext
    {
        get
        {
            return ViewModelProperty.Value;
        }
        set
        {
            if(!mIsInitialized)
            {
                OnInitialize();
                mIsInitialized = true;
            }
            ViewModelProperty.Value = value;
        }
    }

    /// <summary>
    /// View是否初始化过
    /// 用于避免逻辑依赖于显示(比如绑定VM上下文属性变化回调时，依赖于View的显示)
    /// </summary>
    protected bool mIsInitialized;

    public MVVMBaseView()
    {
        // 绑定VM上下文修改回调
        // 避免这种写法，会导致绑定VM上下文属性变化回调依赖于显示
        //ViewModelProperty.OnValueChanged += OnBindingContextChanged;
    }

    /// <summary>
    /// 第一次初始化初始化方法
    /// </summary>
    protected void OnInitialize()
    {
        // 绑定VM上下文修改回调
        ViewModelProperty.OnValueChanged += OnBindingContextChanged;
    }

    /// <summary>
    /// VM动态绑定回调
    /// </summary>
    /// <param name="oldvm"></param>
    /// <param name="newvm"></param>
    protected virtual void OnBindingContextChanged(IMVVMViewModel oldvm, IMVVMViewModel newvm)
    {

    }
}

/*
 * Description:             MVVMView.cs
 * Author:                  TONYTANG
 * Create Date:             2018/09/15
 */

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

/// <summary>
/// MVVMView.cs
/// MVVM里的View
/// </summary>
public class MVVMView : MVVMBaseView{

    /// <summary> Name输入文本(用于View输入改变Name) /// </summary>
    public InputField mInputFieldName;

    /// <summary> Name值展示文本 /// </summary>
    public Text mTxtName;
    
    /// <summary> Age值展示文本 /// </summary>
    public Text mTxtAge;

    /// <summary> Model数据保存按钮 /// </summary>
    public Button mBtnSave;

    /// <summary>
    /// 真实绑定的VM对象访问入口
    /// </summary>
    public MVVMViewModel ViewModel
    {
        get
        {
            return (MVVMViewModel)mMVVMViewModelContext;
        }
    }

    /// <summary>
    /// 响应VM绑定变化回调
    /// 在这里做V和VM绑定相关的事
    /// </summary>
    /// <param name="oldvm"></param>
    /// <param name="newvm"></param>
    protected override void OnBindingContextChanged(IMVVMViewModel oldvm, IMVVMViewModel newvm)
    {
        base.OnBindingContextChanged(oldvm, newvm);
        // 解除老的VM相关绑定
        if(oldvm != null)
        {
            #region Bind VM to V Part
            MVVMViewModel ovm = oldvm as MVVMViewModel;
            ovm.Name.OnValueChanged -= onNameChanged;
            ovm.Age.OnValueChanged -= onAgeChanged;
            #endregion

            #region Bind V To VM
            mInputFieldName.onValueChanged.RemoveListener(onInputNameChanged);
            mBtnSave.onClick.RemoveListener(onSaveClick);
            #endregion
        }

        // 添加新的VM相关绑定
        if (ViewModel != null)
        {
            #region Bind VM to V Part            
            ViewModel.Name.OnValueChanged += onNameChanged;
            ViewModel.Age.OnValueChanged += onAgeChanged;
            #endregion

            #region Bind V To VM
            mInputFieldName.onValueChanged.AddListener(onInputNameChanged);
            mBtnSave.onClick.AddListener(onSaveClick);
            #endregion
        }
    }
    
    #region Bind VM to V Part
    private void onNameChanged(string oldname, string newname)
    {
        mInputFieldName.text = newname;
        mTxtName.text = newname;
    }

    private void onAgeChanged(int oldvalue, int newvalue)
    {
        mTxtAge.text = newvalue.ToString();
    }
    #endregion

    #region Bind V To VM
    private void onInputNameChanged(string newname)
    {
        ViewModel.Name.Value = newname;
    }

    private void onSaveClick()
    {
        ViewModel.saveModel();
    }
    #endregion
}