17.更多跨域调用-协同程序和异步函数
17.1 知识点
复制之前的主入口调用
ILRuntimeManager.Instance.StartILRuntime(() =>
{
//执行ILRuntime当中的一个静态函数
//静态函数中 就是热更工程自己处理的逻辑了
ILRuntimeManager.Instance.appDomain.Invoke("HotFix_Project.ILRuntimeMain", "Start", null, null);
});
在ILRuntime热更工程中使用协同程序
步骤
注册协同程序的跨域继承适配器，可以在示例工程中获取。
在热更工程声明协程并执行
public static IEnumerator Lesson17Courtinue()
{
Debug.Log(0);
yield return new WaitForSeconds(1f);
Debug.Log(1);
yield return new WaitForSeconds(1f);
Debug.Log(2);
yield return new WaitForSeconds(1f);
Debug.Log(3);
yield return new WaitForSeconds(1f);
}
Lesson17_更多跨域调用_协同程序和异步函数 lesson17 = GameObject.FindObjectOfType<Lesson17_更多跨域调用_协同程序和异步函数>();
lesson17.StartCoroutine(Lesson17Courtinue());
重新生成后再Unity会报错，TypeLoadException: Cannot find Adaptor，不能找到协程适配器
示例代码中提供了协程适配器，找到CoroutineAdapter类，在ILruntime管理器直接注册就可以正常使用协程。
//注册协程跨域适配器
appDomain.RegisterCrossBindingAdaptor(new CoroutineAdapter());
在ILRuntime热更工程中使用异步函数
步骤
注册异步函数的跨域继承适配器，可以获取别人写好的异步函数跨域适配器。若无法访问，可以在资料区下载该文件。
导入别人写好的异步适配器IAsyncStateMachineClassInheritanceAdaptor
在热更工程定义异步函数，并调用。重新生成后再Unity运行也会报错。
public static async void Lesson17Async()
{
Debug.Log("Lesson17Async 1");
await Task.Delay(1000);
Debug.Log("Lesson17Async 2");
await Task.Delay(1000);
Debug.Log("Lesson17Async 3");
await Task.Delay(1000);
Debug.Log("Lesson17Async 4");
await Task.Delay(1000);
}
Lesson17Async();
在ILruntime注册异步适配器后可以正常运行
//注册异步跨域适配器
appDomain.RegisterCrossBindingAdaptor(new IAsyncStateMachineClassInheritanceAdaptor());
总结
之所以需要注册跨域继承适配器，是因为在ILRuntime中的协同程序和异步函数编译后本质上是通过状态机利用对象的状态来达到的异步。这里面的对象就用到了跨域继承，所以我们需要注册他们的跨域继承适配器来让热更新工程正常使用他们。
17.2 知识点代码
Lesson17_更多跨域调用_协同程序和异步函数
using System.Collections;
using System.Collections.Generic;
using BaseFramework;
using UnityEngine;
public class Lesson17_更多跨域调用_协同程序和异步函数 : MonoBehaviour
{
void Start()
{
#region 复制之前的主入口调用
ILRuntimeManager.Instance.StartILRuntime(() =>
{
//执行ILRuntime当中的一个静态函数
//静态函数中 就是热更工程自己处理的逻辑了
ILRuntimeManager.Instance.appDomain.Invoke("HotFix_Project.ILRuntimeMain", "Start", null, null);
});
#endregion
#region 知识点一 在ILRuntime热更工程中使用协同程序
//注册 协同程序的 跨域继承适配器
//可以在示例工程中获取
#endregion
#region 知识点二 在ILRuntime热更工程中使用异步函数
//注册 异步函数的 跨域继承适配器
//可以获取别人写好的异步函数跨域适配器
//https://github.com/jumpst/jumpst.github.io/blob/abc112a1ad718910f39bdd34323ae2633551a650/IAsyncStateMachineClassInheritanceAdaptor
//若无法访问，可以在资料区下载该文件
#endregion
#region 总结
//之所以需要注册跨域继承适配器
//是因为在ILRuntime中的协同程序和异步函数
//编译后本质上是通过状态机利用对象的状态来达到的异步
//这里面的对象就用到了跨域继承
//所以我们需要注册他们的跨域继承适配器来让热更新工程正常使用他们
#endregion
}
}
IAsyncStateMachineClassInheritanceAdaptor
using ILRuntime.CLR.Method;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class IAsyncStateMachineClassInheritanceAdaptor : CrossBindingAdaptor
{
public override Type BaseCLRType
{
get { return typeof(System.Runtime.CompilerServices.IAsyncStateMachine); }
}
public override Type AdaptorType
{
get { return typeof(IAsyncStateMachineAdaptor); }
}
public override object CreateCLRInstance(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance)
{
return new IAsyncStateMachineAdaptor(appdomain, instance);
}
public class IAsyncStateMachineAdaptor : System.Runtime.CompilerServices.IAsyncStateMachine, CrossBindingAdaptorType
{
ILTypeInstance instance;
ILRuntime.Runtime.Enviorment.AppDomain appdomain;
CrossBindingMethodInfo mMoveNext_0 = new CrossBindingMethodInfo("MoveNext");
CrossBindingMethodInfo<System.Runtime.CompilerServices.IAsyncStateMachine> mSetStateMachine_1 =
new CrossBindingMethodInfo<System.Runtime.CompilerServices.IAsyncStateMachine>("SetStateMachine");
public IAsyncStateMachineAdaptor()
{
}
public IAsyncStateMachineAdaptor(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance)
{
this.appdomain = appdomain;
this.instance = instance;
}
public ILTypeInstance ILInstance
{
get { return instance; }
}
public void MoveNext()
{
mMoveNext_0.Invoke(this.instance);
}
public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine)
{
mSetStateMachine_1.Invoke(this.instance, stateMachine);
}
public override string ToString()
{
IMethod m = appdomain.ObjectType.GetMethod("ToString", 0);
m = instance.Type.GetVirtualMethod(m);
if (m == null || m is ILMethod)
{
return instance.ToString();
}
else
return instance.Type.FullName;
}
}
}
CoroutineAdapter
using UnityEngine;
using System.Collections.Generic;
using ILRuntime.Other;
using System;
using System.Collections;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;
using ILRuntime.CLR.Method;
public class CoroutineAdapter : CrossBindingAdaptor
{
public override Type BaseCLRType
{
get
{
return null;
}
}
public override Type[] BaseCLRTypes
{
get
{
//跨域继承只能有1个Adapter，因此应该尽量避免一个类同时实现多个外部接口，对于coroutine来说是IEnumerator<object>,IEnumerator和IDisposable，
//ILRuntime虽然支持，但是一定要小心这种用法，使用不当很容易造成不可预期的问题
//日常开发如果需要实现多个DLL外部接口，请在Unity这边先做一个基类实现那些个接口，然后继承那个基类
return new Type[] { typeof(IEnumerator<object>), typeof(IEnumerator), typeof(IDisposable) };
}
}
public override Type AdaptorType
{
get
{
return typeof(Adaptor);
}
}
public override object CreateCLRInstance(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance)
{
return new Adaptor(appdomain, instance);
}
//Coroutine生成的类实现了IEnumerator<System.Object>, IEnumerator, IDisposable,所以都要实现，这个可以通过reflector之类的IL反编译软件得知
internal class Adaptor : IEnumerator<System.Object>, IEnumerator, IDisposable, CrossBindingAdaptorType
{
ILTypeInstance instance;
ILRuntime.Runtime.Enviorment.AppDomain appdomain;
public Adaptor()
{
}
public Adaptor(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance)
{
this.appdomain = appdomain;
this.instance = instance;
}
public ILTypeInstance ILInstance { get { return instance; } }
IMethod mCurrentMethod;
bool mCurrentMethodGot;
public object Current
{
get
{
if (!mCurrentMethodGot)
{
mCurrentMethod = instance.Type.GetMethod("get_Current", 0);
if (mCurrentMethod == null)
{
//这里写System.Collections.IEnumerator.get_Current而不是直接get_Current是因为coroutine生成的类是显式实现这个接口的，通过Reflector等反编译软件可得知
//为了兼容其他只实现了单一Current属性的，所以上面先直接取了get_Current
mCurrentMethod = instance.Type.GetMethod("System.Collections.IEnumerator.get_Current", 0);
}
mCurrentMethodGot = true;
}
if (mCurrentMethod != null)
{
var res = appdomain.Invoke(mCurrentMethod, instance, null);
return res;
}
else
{
return null;
}
}
}
IMethod mDisposeMethod;
bool mDisposeMethodGot;
public void Dispose()
{
if (!mDisposeMethodGot)
{
mDisposeMethod = instance.Type.GetMethod("Dispose", 0);
if (mDisposeMethod == null)
{
mDisposeMethod = instance.Type.GetMethod("System.IDisposable.Dispose", 0);
}
mDisposeMethodGot = true;
}
if (mDisposeMethod != null)
{
appdomain.Invoke(mDisposeMethod, instance, null);
}
}
IMethod mMoveNextMethod;
bool mMoveNextMethodGot;
public bool MoveNext()
{
if (!mMoveNextMethodGot)
{
mMoveNextMethod = instance.Type.GetMethod("MoveNext", 0);
mMoveNextMethodGot = true;
}
if (mMoveNextMethod != null)
{
return (bool)appdomain.Invoke(mMoveNextMethod, instance, null);
}
else
{
return false;
}
}
IMethod mResetMethod;
bool mResetMethodGot;
public void Reset()
{
if (!mResetMethodGot)
{
mResetMethod = instance.Type.GetMethod("Reset", 0);
mResetMethodGot = true;
}
if (mResetMethod != null)
{
appdomain.Invoke(mResetMethod, instance, null);
}
}
public override string ToString()
{
IMethod m = appdomain.ObjectType.GetMethod("ToString", 0);
m = instance.Type.GetVirtualMethod(m);
if (m == null || m is ILMethod)
{
return instance.ToString();
}
else
return instance.Type.FullName;
}
}
}
ILRuntimeManager
using ILRuntime.Mono.Cecil.Pdb;
using ILRuntime.Runtime.Enviorment;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Threading;
using ILRuntime.CLR.Method;
using ILRuntime.CLR.Utils;
using ILRuntime.Runtime.Intepreter;
using ILRuntime.Runtime.Stack;
using Lesson12_FatherNameSpace;
using Lesson13_FatherNameSpace;
using Lesson13_InheritAllNameSpace;
using Lesson13_InterfaceNameSpace;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
namespace BaseFramework
{
public class ILRuntimeManager : BaseSingletonInMonoBehaviour<ILRuntimeManager>
{
public AppDomain appDomain;
//用于存储加载出来的 两个文件的内存流对象
private MemoryStream dllStream;
private MemoryStream pdbStream;
private bool isStart = false;
/// <summary>
/// 用于启动ILRuntime初始化方法
/// </summary>
public void StartILRuntime(UnityAction callBack = null)
{
if (!isStart)
{
isStart = true;
appDomain = new AppDomain();
StartCoroutine(LoadHotUpdateInfo(callBack));
}
}
public void StopILRuntime()
{
//1.释放流
if (dllStream != null)
dllStream.Close();
if (pdbStream != null)
pdbStream.Close();
dllStream = null;
pdbStream = null;
//2.清空appDomain
appDomain = null;
isStart = false;
}
/// <summary>
/// 初始化ILRuntime相关的内容
/// </summary>
unsafe private void InitILRuntime()
{
//其他初始化
//无参无返回值不需要委托注册
//MyUnityDel1因为转成的是无参无返回值的Action，Action在热更新里可以直接使用，所以不需要进行委托的注册
//委托转换器注册（要把自定义委托无参无返回值MyUnityDel1委托转换为Action，其他自定义委托可以看语法也转成Action或Func）
appDomain.DelegateManager.RegisterDelegateConvertor<MyUnityDel1>((act) =>
{
return new MyUnityDel1(() =>
{
((System.Action)act)();
});
});
//有参有返回值委托注册 因为是自己定的规则要自己手动进行委托注册
appDomain.DelegateManager.RegisterFunctionDelegate<System.Int32, System.Int32, System.Int32>();
//委托转换器注册（要把自定义委托有参有返回值MyUnityDel2委托转换为Func，其他自定义委托可以看语法也转成Action或Func）
appDomain.DelegateManager.RegisterDelegateConvertor<MyUnityDel2>((act) =>
{
return new MyUnityDel2((i, j) =>
{
return ((System.Func<System.Int32, System.Int32, System.Int32>)act)(i, j);
});
});
//注册跨域继承的父类适配器
appDomain.RegisterCrossBindingAdaptor((new Lesson12_FatherAdapter()));
appDomain.RegisterCrossBindingAdaptor((new Lesson13_FatherAdapter()));
appDomain.RegisterCrossBindingAdaptor((new Lesson13_InterfaceAdapter()));
appDomain.RegisterCrossBindingAdaptor((new Lesson13_InheritAllAdapter()));
//注册协程跨域适配器
appDomain.RegisterCrossBindingAdaptor(new CoroutineAdapter());
//注册异步跨域适配器
appDomain.RegisterCrossBindingAdaptor(new IAsyncStateMachineClassInheritanceAdaptor());
// 值类型绑定注册
appDomain.RegisterValueTypeBinder(typeof(Vector3), new Vector3Binder());
appDomain.RegisterValueTypeBinder(typeof(Vector2), new Vector2Binder());
appDomain.RegisterValueTypeBinder(typeof(Quaternion), new QuaternionBinder());
//CLR重定向内容 要写到CLR绑定之前
//得到想要重定向类的Type
System.Type debugType = typeof(Debug);
//得到想要重定向方法的方法信息
MethodInfo methodInfo = debugType.GetMethod("Log", new System.Type[] { typeof(object) });
//进行CLR重定向
appDomain.RegisterCLRMethodRedirection(methodInfo, MyLog);
//注册CLR绑定信息
ILRuntime.Runtime.Generated.CLRBindings.Initialize(appDomain);
//初始化ILRuntime相关信息（目前只需要告诉ILRuntime主线程的线程ID，主要目的是能够在Unity的Profiler剖析器窗口中分析问题）
appDomain.UnityMainThreadID = Thread.CurrentThread.ManagedThreadId;
}
// MyLog函数用于记录日志，并输出调用栈信息
// 参数：
// __intp: ILRuntime解释器实例
// __esp: 栈指针
// __mStack: 托管堆栈
// __method: 当前方法
// isNewObj: 是否为新对象
unsafe StackObject* MyLog(ILIntepreter __intp, StackObject* __esp, List<object> __mStack, CLRMethod __method, bool isNewObj)
{
// 获取当前应用程序域
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
// 指针的声明
StackObject* ptr_of_this_method;
// 为了方便减法运算，计算栈顶指针位置
StackObject* __ret = ILIntepreter.Minus(__esp, 1);
// 获取栈顶参数的指针
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
// 将栈顶参数转换为System.Object类型
System.Object @message = (System.Object)typeof(System.Object).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (ILRuntime.CLR.Utils.Extensions.TypeFlags)0);
// 释放栈顶参数的指针
__intp.Free(ptr_of_this_method);
// 获取调用栈信息 是我们自己添加的
var stackTrace = __domain.DebugService.GetStackTrace(__intp);
// 输出日志信息和调用栈信息
UnityEngine.Debug.Log(@message + "\n" + stackTrace);
return __ret;
}
/// <summary>
/// 启动完毕并且初始化完毕后 想要执行的热更新的逻辑
/// </summary>
private void ILRuntimeLoadOverDoSomthing()
{
}
/// <summary>
/// 去异步加载我们的热更相关的dll和pdb文件
/// </summary>
/// <returns></returns>
IEnumerator LoadHotUpdateInfo(UnityAction callBack)
{
//这部分知识点在 Unity网络开发基础当中有讲解
//加载本地的DLL文件
#if UNITY_ANDROID
UnityWebRequest reqDll = UnityWebRequest.Get(Application.streamingAssetsPath + "/HotFix_Project.dll");
#else
UnityWebRequest reqDll =
UnityWebRequest.Get("file:///" + Application.streamingAssetsPath + "/HotFix_Project.dll");
#endif
yield return reqDll.SendWebRequest();
//如果失败了
if (reqDll.result != UnityWebRequest.Result.Success)
print("加载DLL文件失败" + reqDll.responseCode + reqDll.result);
//读取加载的DLL数据
byte[] dll = reqDll.downloadHandler.data;
reqDll.Dispose();
#if UNITY_ANDROID
UnityWebRequest reqPdb = UnityWebRequest.Get(Application.streamingAssetsPath + "/HotFix_Project.pdb");
#else
UnityWebRequest reqPdb =
UnityWebRequest.Get("file:///" + Application.streamingAssetsPath + "/HotFix_Project.pdb");
#endif
yield return reqPdb.SendWebRequest();
//如果失败了
if (reqPdb.result != UnityWebRequest.Result.Success)
print("加载Pdb文件失败" + reqPdb.responseCode + reqPdb.result);
//读取加载的DLL数据
byte[] pdb = reqPdb.downloadHandler.data;
reqPdb.Dispose();
//3.将加载的数据以流的形式(文件流或者内存流对象)传递给AppDomain对象中的LoadAssembly方法
//注意 这里使用流 不要用完就关 一定要等到热更相关内容不使用了 再关闭
dllStream = new MemoryStream(dll);
pdbStream = new MemoryStream(pdb);
//将我们两个文件的内存流用于初始化 appDomain 我们之后就可以通过该对象来执行我们对应的热更代码了
appDomain.LoadAssembly(dllStream, pdbStream, new PdbReaderProvider());
InitILRuntime();
ILRuntimeLoadOverDoSomthing();
//当ILRuntime启动完毕 想要在外部执行的内容
callBack?.Invoke();
}
}
}
ILRuntimeMain
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
namespace HotFix_Project
{
#region 委托调用
public delegate void MyILRuntimeDel1();
public delegate int MyILRuntimeDel2(int i, int j);
#endregion
class ILRuntimeMain
{
/// <summary>
/// 把逻辑处理权交给热更工程
/// 它是一个启动函数
/// </summary>
public static void Start()
{
#region ILRuntime调用Unity
////使用ILRuntime创建的空物体
//GameObject obj = new GameObject("ILRuntime创建的空物体");
//obj.transform.position = new Vector3(10, 10, 10);
////Debug.Log(obj.transform.position);//(10.00, 10.00, 10.00)
////添加物理的dll后 可以正常使用Rigidbody了
//Rigidbody rigidBody = obj.AddComponent<Rigidbody>();
//rigidBody.mass = 9999;
//// 可以直接添加Unity自己写的脚本
//obj.AddComponent<Lesson10_Test>();
#endregion
#region 委托调用
////在ILRuntime中 申明 Unity中自定义委托变量 装载 ILRuntime的函数 正常使用
//MyUnityDel1 fun = Fun1;
//fun();//IL_Fun1
//MyUnityDel2 fun2 = Fun2;
//int result = fun2(5, 6);//IL_Fun2
//Debug.Log(result);//11
////在Unity中 申明 Unity中自定义委托变量 关联ILRuntime工程中的函数
////找到我们在Unity的脚本
//Lesson11_更多跨域调用_委托调用 lesson11 = GameObject.FindObjectOfType<Lesson11_更多跨域调用_委托调用>();
////直接设置Unity中自定义委托变量为ILRuntime工程中的函数会报错
////报错信息：KeyNotFoundException: Cannot find convertor for global::MyUnityDel1
////使用自定义委托
////注册MyUnityDel1和MyUnityDel2的委托和委托转换器后才能正常执行
//lesson11.fun = Fun1;
//lesson11.fun();//IL_Fun1
//lesson11.fun2 = Fun2;
//result = lesson11.fun2(7, 7);//IL_Fun2
//Debug.Log(result);//14
////使用Action或者Func
////因为使用的是Action或者Func 不需要注册委托转换器
//lesson11.funAction = Fun1;
//lesson11.funAction();//IL_Fun1
//lesson11.funFunc = Fun2;
//result = lesson11.funFunc(8, 8);//IL_Fun2
//Debug.Log(result);//16
////在ILRuntime中自定义委托后使用 直接使用
//MyILRuntimeDel1 funIL = Fun1;
//funIL();//IL_Fun1
//MyILRuntimeDel2 funIL2 = Fun2;
//result = fun2(1, 1);//IL_Fun2
//Debug.Log(result);//2
#endregion
#region 跨域继承Unity中的类
//Lesson12_Son lesson12_Son = new Lesson12_Son();
//lesson12_Son.TestFun("哈哈哈");
//lesson12_Son.TestAbstract(99);
//lesson12_Son.valuePublic = 100;
#endregion
#region 跨域继承Unity中的类的注意事项
//Lesson13_Son lesson13_Son = new Lesson13_Son();
//lesson13_Son.TestAbstract(666);
//lesson13_Son.TestInterface();
//Lesson13_InheritAllSon lesson13_InheritAll = new Lesson13_InheritAllSon();
//lesson13_InheritAll.TestAbstract(666);
//lesson13_InheritAll.TestInterface();
#endregion
#region CLR重定向和CLR绑定
////得到当前系统时间
//System.DateTime currentTime = System.DateTime.Now;
//for (int i = 0; i < 100000; i++)
//{
// Lesson14_更多跨域调用_CLR重定向和CLR绑定.TestFun(i, i);
//}
//Debug.Log("十万次循环花费的时间：" + (System.DateTime.Now - currentTime).TotalMilliseconds + "ms");
#endregion
#region 值类型绑定
//System.DateTime currentTime = System.DateTime.Now;
//Vector3 v1 = new Vector3(123, 54, 567);
//Vector3 v2 = new Vector3(342, 678, 123);
//float dot = 0;
//for (int i = 0; i < 1000000; i++)
//{
// dot += Vector3.Dot(v1, v2);
//}
//Vector2 v3 = new Vector2(12, 56);
//Vector2 v4 = new Vector2(123123, 45345);
//for (int i = 0; i < 1000000; i++)
//{
// dot += Vector3.Dot(v3, v4);
//}
//Debug.Log("值类型计算花费的时间：" + (System.DateTime.Now - currentTime).TotalMilliseconds + "ms");
#endregion
#region 热更工程中使用MonoBehaviour
//GameObject obj = new GameObject();
//ILRuntimeMono mono = obj.AddComponent<ILRuntimeMono>();
////由于Awake执行时机的特殊性 Awake会在脚本添加时自动执行 我们可以在添加了对应脚本后直接执行初始化相关逻辑即可
////无需通过事件或者委托的形式去触发它
//Debug.Log("Awake");
////mono.awakeEvent += () =>
////{
//// Debug.Log("Awake");
////};
//mono.startEvent += () =>
//{
// Debug.Log("Start");
//};
//mono.updateEvent += () =>
//{
// Debug.Log("Update");
//};
#endregion
#region 协同程序和异步函数
Lesson17_更多跨域调用_协同程序和异步函数 lesson17 = GameObject.FindObjectOfType<Lesson17_更多跨域调用_协同程序和异步函数>();
lesson17.StartCoroutine(Lesson17Courtinue());
Lesson17Async();
#endregion
}
#region 委托调用
public static void Fun1()
{
Debug.Log("IL_Fun1");
}
public static int Fun2(int a, int b)
{
Debug.Log("IL_Fun2");
return a + b;
}
#endregion
#region 协同程序和异步函数
public static IEnumerator Lesson17Courtinue()
{
Debug.Log(0);
yield return new WaitForSeconds(1f);
Debug.Log(1);
yield return new WaitForSeconds(1f);
Debug.Log(2);
yield return new WaitForSeconds(1f);
Debug.Log(3);
yield return new WaitForSeconds(1f);
}
public static async void Lesson17Async()
{
Debug.Log("Lesson17Async 1");
await Task.Delay(1000);
Debug.Log("Lesson17Async 2");
await Task.Delay(1000);
Debug.Log("Lesson17Async 3");
await Task.Delay(1000);
Debug.Log("Lesson17Async 4");
await Task.Delay(1000);
}
#endregion
}
}
17.3 练习题
想要在ILRuntime中使用协同程序和异步函数我们需要做什么？
在Unity中注册协同程序和异步函数相关的跨域继承适配器
协同程序跨域继承适配器 可以在实例工程中获取
异步函数跨域继承适配器 可以在Github上获取
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com
