unity游戏开发：解析ET6接入ILRuntime实现热更新

mastertravels77 · 发表于 2022-1-17 05:49

1.介绍

ILRuntime项目为基于C#的平台（例如Unity）提供了一个纯C#实现，快速、方便且可靠的IL运行时，使得能够在不支持JIT的硬件环境（如iOS）能够实现代码的热更新
ET是一个开源的游戏客户端（基于unity3d）服务端双端框架，服务端是使用C# .net core开发的分布式游戏服务端，其特点是开发效率高，性能强，双端共享逻辑代码，客户端服务端热更机制完善，同时支持可靠udp tcp websocket协议，支持服务端3D recast寻路等等。
2.接入ILRuntime

1.BuildAssemblieEditor.cs

构建codes.dll和codes.pdb到unity工程中并打上ab标签

public static class BuildAssemblieEditor
{
      //dll复制到unity工程的路径
      private const string CodeDir = &#34;Assets/Bundles/Code/&#34;;
      [MenuItem(&#34;Tools/BuildCode _F5&#34;)]
      public static void BuildCode()
      {
//将codes目录下的所有cs文件打成code.dll
         BuildAssemblieEditor.BuildMuteAssembly(&#34;Code&#34;, new []
         {
            &#34;Codes/Model/&#34;,
            &#34;Codes/ModelView/&#34;,
            &#34;Codes/Hotfix/&#34;,
            &#34;Codes/HotfixView/&#34;
         }, Array.Empty<string>());
//将code.dll复制到unity工程路径下并打上ab标签
         AfterCompiling();
         //刷新资源
         AssetDatabase.Refresh();
      }
private static void BuildMuteAssembly(string assemblyName, string[] CodeDirectorys, string[] additionalReferences)
      {
         //获取CodeDirectorys路径下的所有cs文件
         List<string> scripts = new List<string>();
         for (int i = 0; i < CodeDirectorys.Length; i++)
         {
            DirectoryInfo dti = new DirectoryInfo(CodeDirectorys);
            FileInfo[] fileInfos = dti.GetFiles(&#34;*.cs&#34;, System.IO.SearchOption.AllDirectories);
            for (int j = 0; j < fileInfos.Length; j++)
            {
                  scripts.Add(fileInfos[j].FullName);
            }
         }
         //编译dll的路径
         string dllPath = Path.Combine(Define.BuildOutputDir, $&#34;{assemblyName}.dll&#34;);
         string pdbPath = Path.Combine(Define.BuildOutputDir, $&#34;{assemblyName}.pdb&#34;);
         File.Delete(dllPath);
         File.Delete(pdbPath);
         Directory.CreateDirectory(Define.BuildOutputDir);
         AssemblyBuilder assemblyBuilder = new AssemblyBuilder(dllPath, scripts.ToArray());
         //启用UnSafe
//assemblyBuilder.compilerOptions.AllowUnsafeCode = true;
         BuildTargetGroup buildTargetGroup = BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget);
         assemblyBuilder.compilerOptions.ApiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup);
         // assemblyBuilder.compilerOptions.ApiCompatibilityLevel = ApiCompatibilityLevel.NET_4_6;
         //传递给程序集编译的其他程序集引用。
         assemblyBuilder.additionalReferences = additionalReferences;
         assemblyBuilder.flags = AssemblyBuilderFlags.DevelopmentBuild;
//AssemblyBuilderFlags.None                正常发布
//AssemblyBuilderFlags.DevelopmentBuild    开发模式打包
//AssemblyBuilderFlags.EditorAssembly    编辑器状态
         assemblyBuilder.referencesOptions = ReferencesOptions.UseEngineModules;
         assemblyBuilder.buildTarget = EditorUserBuildSettings.activeBuildTarget;
         assemblyBuilder.buildTargetGroup = buildTargetGroup;
         //编译开始回调
         assemblyBuilder.buildStarted += delegate(string assemblyPath) { Debug.LogFormat(&#34;build start：&#34; + assemblyPath); };
         //编译结束回调
         assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages)
         {
            int errorCount = compilerMessages.Count(m => m.type == CompilerMessageType.Error);
            int warningCount = compilerMessages.Count(m => m.type == CompilerMessageType.Warning);
            Debug.LogFormat(&#34;Warnings: {0} - Errors: {1}&#34;, warningCount, errorCount);
            if (warningCount > 0)
            {
                  Debug.LogFormat(&#34;有{0}个Warning!!!&#34;, warningCount);
            }
            if (errorCount > 0)
            {
                  for (int i = 0; i < compilerMessages.Length; i++)
                  {
                     if (compilerMessages.type == CompilerMessageType.Error)
                     {
                        Debug.LogError(compilerMessages.message);
                     }
                  }
            }
         };
         //开始构建
         if (!assemblyBuilder.Build())
         {
            Debug.LogErrorFormat(&#34;build fail：&#34; + assemblyBuilder.assemblyPath);
            return;
         }
      }
      private static void AfterCompiling()
      {
         //编译中
         while (EditorApplication.isCompiling)
         {
            Debug.Log(&#34;Compiling wait1&#34;);
            // 主线程sleep并不影响编译线程
            Thread.Sleep(1000);
            Debug.Log(&#34;Compiling wait2&#34;);
         }
         Debug.Log(&#34;Compiling finish&#34;);
         //将dll和pdb拷贝到unity工程中
         Directory.CreateDirectory(CodeDir);
         File.Copy(Path.Combine(Define.BuildOutputDir, &#34;Code.dll&#34;), Path.Combine(CodeDir, &#34;Code.dll.bytes&#34;), true);
         File.Copy(Path.Combine(Define.BuildOutputDir, &#34;Code.pdb&#34;), Path.Combine(CodeDir, &#34;Code.pdb.bytes&#34;), true);
         AssetDatabase.Refresh();
         Debug.Log(&#34;copy Code.dll to Bundles/Code success!&#34;);
         // 设置ab包
         AssetImporter assetImporter1 = AssetImporter.GetAtPath(&#34;Assets/Bundles/Code/Code.dll.bytes&#34;);
         assetImporter1.assetBundleName = &#34;Code.unity3d&#34;;
         AssetImporter assetImporter2 = AssetImporter.GetAtPath(&#34;Assets/Bundles/Code/Code.pdb.bytes&#34;);
         assetImporter2.assetBundleName = &#34;Code.unity3d&#34;;
         AssetDatabase.Refresh();
         Debug.Log(&#34;set assetbundle success!&#34;);
         Debug.Log(&#34;build success!&#34;);
      }
}
2.CodeLoader.cs

初始化ILRuntime并启动热更层开始函数

case Define.CodeMode_ILRuntime:
{
//从ab包中加载dll和pdb
Dictionary<string, UnityEngine.Object> dictionary = AssetsBundleHelper.LoadBundle(&#34;code.unity3d&#34;);
byte[] assBytes = ((TextAsset)dictionary[&#34;Code.dll&#34;]).bytes;
byte[] pdbBytes = ((TextAsset)dictionary[&#34;Code.pdb&#34;]).bytes;
AppDomain appDomain = new AppDomain();
MemoryStream assStream = new MemoryStream(assBytes);
MemoryStream pdbStream = new MemoryStream(pdbBytes);
//ILRuntime加载程序集
appDomain.LoadAssembly(assStream, pdbStream, new ILRuntime.Mono.Cecil.Pdb.PdbReaderProvider());
//注册委托适配器等
ILHelper.InitILRuntime(appDomain);
//缓存所有热更反射类型
this.allTypes = appDomain.LoadedTypes.Values.Select(x => x.ReflectionType).ToArray();
//调用到热更层的entry类的start方法
IStaticMethod start = new ILStaticMethod(appDomain, &#34;ET.Entry&#34;, &#34;Start&#34;, 0);
start.Run();
break;
}
3.ILHelper.cs

注册重定向函数，委托，适配器，clr绑定

public static class ILHelper
{
      public static List<Type> list = new List<Type>();
      public static void InitILRuntime(ILRuntime.Runtime.Enviorment.AppDomain appdomain)
      {
         // 注册重定向函数
         list.Add(typeof(Dictionary<int, ILTypeInstance>));
         list.Add(typeof(Dictionary<int, int>));
         list.Add(typeof(Dictionary<object, object>));
         list.Add(typeof(Dictionary<int, object>));
         list.Add(typeof(Dictionary<long, object>));
         list.Add(typeof(Dictionary<long, int>));
         list.Add(typeof(Dictionary<int, long>));
         list.Add(typeof(Dictionary<string, long>));
         list.Add(typeof(Dictionary<string, int>));
         list.Add(typeof(Dictionary<string, object>));
         list.Add(typeof(List<ILTypeInstance>));
         list.Add(typeof(List<int>));
         list.Add(typeof(List<long>));
         list.Add(typeof(List<string>));
         list.Add(typeof(List<object>));
         list.Add(typeof(ListComponent<ILTypeInstance>));
         list.Add(typeof(ETTask<int>));
         list.Add(typeof(ETTask<long>));
         list.Add(typeof(ETTask<string>));
         list.Add(typeof(ETTask<object>));
         list.Add(typeof(ETTask<AssetBundle>));
         list.Add(typeof(ETTask<UnityEngine.Object[]>));
         list.Add(typeof(ListComponent<ETTask>));
         list.Add(typeof(ListComponent<Vector3>));
         // 注册委托
         appdomain.DelegateManager.RegisterMethodDelegate<List<object>>();
         appdomain.DelegateManager.RegisterMethodDelegate<object>();
         appdomain.DelegateManager.RegisterMethodDelegate<bool>();
         appdomain.DelegateManager.RegisterMethodDelegate<string>();
         appdomain.DelegateManager.RegisterMethodDelegate<float>();
         appdomain.DelegateManager.RegisterMethodDelegate<long, int>();
         appdomain.DelegateManager.RegisterMethodDelegate<long, MemoryStream>();
         appdomain.DelegateManager.RegisterMethodDelegate<long, IPEndPoint>();
         appdomain.DelegateManager.RegisterMethodDelegate<ILTypeInstance>();
         appdomain.DelegateManager.RegisterMethodDelegate<AsyncOperation>();
         appdomain.DelegateManager.RegisterFunctionDelegate<UnityEngine.Events.UnityAction>();
         appdomain.DelegateManager.RegisterFunctionDelegate<System.Object, ET.ETTask>();
         appdomain.DelegateManager.RegisterFunctionDelegate<ILTypeInstance, bool>();
         appdomain.DelegateManager.RegisterFunctionDelegate<System.Collections.Generic.KeyValuePair<System.String, System.Int32>, System.String>();
         appdomain.DelegateManager.RegisterFunctionDelegate<System.Collections.Generic.KeyValuePair<System.Int32, System.Int32>, System.Boolean>();
         appdomain.DelegateManager.RegisterFunctionDelegate<System.Collections.Generic.KeyValuePair<System.String, System.Int32>, System.Int32>();
         appdomain.DelegateManager.RegisterFunctionDelegate<List<int>, int>();
         appdomain.DelegateManager.RegisterFunctionDelegate<List<int>, bool>();
         appdomain.DelegateManager.RegisterFunctionDelegate<int, bool>();//Linq
         appdomain.DelegateManager.RegisterFunctionDelegate<int, int, int>();//Linq
         appdomain.DelegateManager.RegisterFunctionDelegate<KeyValuePair<int, List<int>>, bool>();
         appdomain.DelegateManager.RegisterFunctionDelegate<KeyValuePair<int, int>, KeyValuePair<int, int>, int>();
         appdomain.DelegateManager.RegisterDelegateConvertor<UnityEngine.Events.UnityAction>((act) =>
         {
            return new UnityEngine.Events.UnityAction(() =>
            {
                  ((Action)act)();
            });
         });
         appdomain.DelegateManager.RegisterDelegateConvertor<Comparison<KeyValuePair<int, int>>>((act) =>
         {
            return new Comparison<KeyValuePair<int, int>>((x, y) =>
            {
                  return ((Func<KeyValuePair<int, int>, KeyValuePair<int, int>, int>)act)(x, y);
            });
         });
         // 注册适配器
         RegisterAdaptor(appdomain);
         //注册Json的CLR
         LitJson.JsonMapper.RegisterILRuntimeCLRRedirection(appdomain);
         //注册ProtoBuf的CLR
         PType.RegisterILRuntimeCLRRedirection(appdomain);
         //clr绑定初始化
         CLRBindings.Initialize(appdomain);
      }
      public static void RegisterAdaptor(ILRuntime.Runtime.Enviorment.AppDomain appdomain)
      {
         //注册自己写的适配器
         appdomain.RegisterCrossBindingAdaptor(new IAsyncStateMachineClassInheritanceAdaptor());
      }
}

		自动登录	找回密码
密码			立即注册

[笔记] unity游戏开发：解析ET6接入ILRuntime实现热更新