ILRuntime第四课Inheritance

最新推荐文章于 2023-03-13 03:57:45 发布
最新推荐文章于 2023-03-13 03:57:45 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： ILRuntime 文章标签： ILRuntime Inheritance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YE_wolf/article/details/76921198
版权

在DLL热更中，如果需要继承主项目中的类或者接口的话，需要为其写一个适配器

1.主工程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
using  UnityEngine;
using  System.Collections;
using  System.Collections.Generic;
using  System.IO;
using  ILRuntime.CLR.TypeSystem;
using  ILRuntime.CLR.Method;
using  ILRuntime.Runtime.Enviorment;
 
public  abstract  class  TestClassBase
{
     public  virtual  int  Value
     {
         get
         {
             return  0;
         }
     }
 
     public  virtual  void  TestVirtual( string  str)
     {
         Debug.Log( "!! TestClassBase.TestVirtual, str = "  + str);
     }
 
     public  abstract  void  TestAbstract( int  gg);
}
public  class  Inheritance : MonoBehaviour
{
     //AppDomain是ILRuntime的入口，最好是在一个单例类中保存，整个游戏全局就一个，这里为了示例方便，每个例子里面都单独做了一个
     //大家在正式项目中请全局只创建一个AppDomain
     AppDomain appdomain;
 
     void  Start()
     {
         StartCoroutine(LoadHotFixAssembly());
     }
 
     IEnumerator LoadHotFixAssembly()
     {
         //首先实例化ILRuntime的AppDomain，AppDomain是一个应用程序域，每个AppDomain都是一个独立的沙盒
         appdomain =  new  ILRuntime.Runtime.Enviorment.AppDomain();
         //正常项目中应该是自行从其他地方下载dll，或者打包在AssetBundle中读取，平时开发以及为了演示方便直接从StreammingAssets中读取，
         //正式发布的时候需要大家自行从其他地方读取dll
 
         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         //这个DLL文件是直接编译HotFix_Project.sln生成的，已经在项目中设置好输出目录为StreamingAssets，在VS里直接编译即可生成到对应目录，无需手动拷贝
#if UNITY_ANDROID
         WWW www =  new  WWW(Application.streamingAssetsPath +  "/HotFix_Project.dll" );
#else
         WWW www =  new  WWW( "file:///"  + Application.streamingAssetsPath +  "/HotFix_Project.dll" );
#endif
         while  (!www.isDone)
             yield  return  null ;
         if  (! string .IsNullOrEmpty(www.error))
             UnityEngine.Debug.LogError(www.error);
         byte [] dll = www.bytes;
         www.Dispose();
 
         //PDB文件是调试数据库，如需要在日志中显示报错的行号，则必须提供PDB文件，不过由于会额外耗用内存，正式发布时请将PDB去掉，下面LoadAssembly的时候pdb传null即可
#if UNITY_ANDROID
         www =  new  WWW(Application.streamingAssetsPath +  "/HotFix_Project.pdb" );
#else
         www =  new  WWW( "file:///"  + Application.streamingAssetsPath +  "/HotFix_Project.pdb" );
#endif
         while  (!www.isDone)
             yield  return  null ;
         if  (! string .IsNullOrEmpty(www.error))
             UnityEngine.Debug.LogError(www.error);
         byte [] pdb = www.bytes;
         using  (System.IO.MemoryStream fs =  new  MemoryStream(dll))
         {
             using  (System.IO.MemoryStream p =  new  MemoryStream(pdb))
             {
                 appdomain.LoadAssembly(fs, p,  new  Mono.Cecil.Pdb.PdbReaderProvider());
             }
         }
 
         InitializeILRuntime();
         OnHotFixLoaded();
     }
 
     void  InitializeILRuntime()
     {
         //这里做一些ILRuntime的注册，这里应该写继承适配器的注册，为了演示方便，这个例子写在OnHotFixLoaded了
     }
 
     void  OnHotFixLoaded()
     {
         Debug.Log( "首先我们来创建热更里的类实例" );
         TestClassBase obj;
         try
         {
             obj = appdomain.Instantiate<TestClassBase>( "HotFix_Project.TestInheritance" );
         }
         catch (System.Exception ex)
         {
             Debug.LogError(ex.ToString());
         }
         Debug.Log( "Oops, 报错了，因为跨域继承必须要注册适配器。 如果是热更DLL里面继承热更里面的类型，不需要任何注册。" );
 
         Debug.Log( "所以现在我们来注册适配器" );
         appdomain.RegisterCrossBindingAdaptor( new  InheritanceAdapter());
         Debug.Log( "现在再来尝试创建一个实例" );
         obj = appdomain.Instantiate<TestClassBase>( "HotFix_Project.TestInheritance" );
         Debug.Log( "现在来调用成员方法" );
         obj.TestAbstract(123);
         obj.TestVirtual( "Hello" );
 
         Debug.Log( "现在换个方式创建实例" );
         obj = appdomain.Invoke( "HotFix_Project.TestInheritance" ,  "NewObject" ,  null ,  null )  as  TestClassBase;
         obj.TestAbstract(456);
         obj.TestVirtual( "Foobar" );
 
     }
 
     void  Update()
     {
 
     }
}

2.适配器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
using  ILRuntime.Runtime.Enviorment;
using  System;
using  System.Collections.Generic;
using  ILRuntime.Runtime.Intepreter;
using  ILRuntime.CLR.Method;
 
public  class  ClassInheritanceAdaptor : CrossBindingAdaptor
{
     public  override  Type BaseCLRType
     {
         get
         {
             //想继承的类
             return  typeof (TestClassBase);
             //若想一个DLL类实现多个主工程中的接口，则return null
         }
     }
 
     public  override  Type[] BaseCLRTypes
     {
         get
         {
             //跨域继承只能有1个Adapter，因此应该尽量避免一个类同时实现多个外部接口，
             //ILRuntime虽然支持同时实现多个接口，但是一定要小心这种用法，使用不当很容易造成不可预期的问题
             //日常开发如果需要实现多个DLL外部接口，请在Unity这边先做一个基类实现那些个接口，然后继承那个基类
             //如需一个Adapter实现多个接口，请用下面这行
             //return new Type[] { typeof(IEnumerator<object>), typeof(IEnumerator), typeof(IDisposable) };
             return  null ;
         }
     }
 
     public  override  Type AdaptorType
     {
         get
         {
             return  typeof (Adaptor); //这是实际的适配器类
         }
     }
 
     public  override  object  CreateCLRInstance(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance)
     {
         return  new  Adaptor(appdomain, instance); //创建一个新的实例
     }
 
     //实际的适配器类需要继承你想继承的那个类，并且实现CrossBindingAdaptorType接口
     class  Adaptor : TestClassBase, CrossBindingAdaptorType
     {
         ILTypeInstance instance;
         ILRuntime.Runtime.Enviorment.AppDomain appdomain;
 
         //抽象方法
         IMethod mTestAbstract;
         bool  mTestAbstractGot;
         //虚方法
         IMethod mTestVirtual;
         bool  mTestVirtualGot;
         //标志位，确定虚函数是否在调用中
         bool  isTestVirtualInvoking =  false ;
         //获取值
         IMethod mGetValue;
         bool  mGetValueGot;
 
         bool  isGetValueInvoking =  false ;
         //缓存这个数组来避免调用时的GC Alloc
         object [] param1 =  new  object [1];
 
         //构造方法
         public  Adaptor()
         {
 
         }
 
         public  Adaptor(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance)
         {
             this .appdomain = appdomain;
             this .instance = instance;
         }
 
         public  ILTypeInstance ILInstance {  get  {  return  instance; } }
 
         //你需要重写所有你希望在热更脚本里面重写的方法，并且将控制权转到脚本里去
         public  override  void  TestAbstract( int  ab)
         {
             if  (!mTestAbstractGot)
             {
                 mTestAbstract = instance.Type.GetMethod( "TestAbstract" , 1);
                 mTestAbstractGot =  true ;
             }
             if  (mTestAbstract !=  null )
             {
                 param1[0] = ab;
                 appdomain.Invoke(mTestAbstract, instance, param1); //没有参数建议显式传递null为参数列表，否则会自动new object[0]导致GC Alloc
             }
         }
 
         public  override  void  TestVirtual( string  str)
         {
             if  (!mTestVirtualGot)
             {
                 mTestVirtual = instance.Type.GetMethod( "TestVirtual" , 1);
                 mTestVirtualGot =  true ;
             }
             //对于虚函数而言，必须设定一个标识位来确定是否当前已经在调用中，否则如果脚本类中调用base.TestVirtual()就会造成无限循环，最终导致爆栈
             if  (mTestVirtual !=  null  && !isTestVirtualInvoking)
             {
                 isTestVirtualInvoking =  true ;
                 param1[0] = str;
                 appdomain.Invoke(mTestVirtual, instance, param1);
                 isTestVirtualInvoking =  false ;
             }
             else
                 base .TestVirtual(str);
         }
 
         public  override  int  Value
         {
             get
             {
                 if  (!mGetValueGot)
                 {
                     //属性的Getter编译后会以get_XXX存在，如果不确定的话可以打开Reflector等反编译软件看一下函数名称
                     mGetValue = instance.Type.GetMethod( "get_Value" , 1);
                     mGetValueGot =  true ;
                 }
                 //对于虚函数而言，必须设定一个标识位来确定是否当前已经在调用中，否则如果脚本类中调用base.Value就会造成无限循环，最终导致爆栈
                 if  (mGetValue !=  null  && !isGetValueInvoking)
                 {
                     isGetValueInvoking =  true ;
                     var  res = ( int )appdomain.Invoke(mGetValue, instance,  null );
                     isGetValueInvoking =  false ;
                     return  res;
                 }
                 else
                     return  base .Value;
             }
         }
 
         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;
         }
     }
 
 
}

3.DLL热更中继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using  System;
using  System.Collections.Generic;
 
namespace  HotFix_Project
{
     //一定要特别注意，:后面只允许有1个Unity主工程的类或者接口，但是可以有随便多少个热更DLL中的接口
     public  class  TestInheritance : TestClassBase
     {
         public  override  void  TestAbstract( int  gg)
         {
             UnityEngine.Debug.Log( "!! TestInheritance.TestAbstract gg ="  + gg);
         }
 
         public  override  void  TestVirtual( string  str)
         {
             base .TestVirtual(str);
             UnityEngine.Debug.Log( "!! TestInheritance.TestVirtual str ="  + str);
         }
 
         public  static  TestInheritance NewObject()
         {
             return  new  HotFix_Project.TestInheritance();
         }
     }
}

​












YE_wolf
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity项目热更新（ILRunTime中跨域继承第四篇）
wangyonghui1的博客
08-19 682
热更新的dll项目想要继承主工程的类或者接口必须在主工程中写一个适配器 接口类的代码如下： using System; using Game.CocoRenderer; using ILRuntime.CLR.Method; using ILRuntime.Runtime.Enviorment; using ILRuntime.Runtime.Intepreter; using UnityEngine; namespace ILRuntime.Adapters.GameAdaptor { pub
第4课票务类
02-20
5. 继承（Inheritance） 在票务类的设计中，可能有多种类型的票，如普通票、贵宾票等。我们可以利用C#的继承特性，让这些子类继承自一个共同的基类`Ticket`，这样可以重用代码并增加代码的可扩展性。 6. 封装...
ILRuntime学习笔记（四）——跨域继承
weixin_45724919的博客
03-13 480
如果你的类无需引擎提供的各种初始化, 更新及析构, 物理, 渲染等的回调. 最好不要继承MonoBehavior。继承后, 引擎会在事件触发时, 通过反射调用各种函数. 这是需要消耗性能的。3.热更DLL不能同时继承或实现1个以上主工程的类型或接口。1.热更DLL中继承Unity主工程的类型称为跨域继承。"ILRuntime/生成跨域继承适配器"2.跨域继承需要编写跨域继承适配器。4.尽量避免跨域继承，尤其避免继承。
ILRuntime入门05 类继承
HiggsParticleHYX的博客
08-18 572
使用流程 我们可能需要热更工程去继承Unity工程中的类，那么我们就需要为其写一个适配器，具体流程如下： 新建Unity工程父类 public abstract class TestClassBase { public virtual int Value { get { return 0; } set { } } public virtual voi
Unity热更新 ILRuntime 从零开始 继承 Inheritance（五）
水光涵月的博客
10-08 1622
热更新 ILRuntime 从零开始 继承 Inheritance（五）前言一、继承分类二、跨域继承的用法1.继承适配器2.实际应用总结????????版权声明 前言 我们继续来一起看下ILRuntime的第四个案例———Inheritance：继承。 这一篇主要讲的是ILRuntime的继承问题，如果是全部在热更工程中的继承，用法跟普通继承是一样的。如果你想在热更DLL项目当中继承一个Unity主工程里的类，或者实现一个主工程里的接口，这就是禁停啊要讲的跨域继承，你需要在Unity主工程中实现一个继承
ILRuntime学习记录 - 跨域委托、跨域继承等
Ha啤酒来大杯的博客
07-14 1195
跨域委托注册及转换 注册 public delegate void TestDelegateMethod(int a); public delegate string TestDelegateFunction(int a); public static TestDelegateMethod TestMethodDelegate; public static TestDelegateFunction TestFunctionDelegate; 注册无返回值委托 appdomain.De.
JAVA基础之继承（inheritance）详解
08-31
在Java面向对象编程（OOP）中，继承（Inheritance）是实现代码重用和抽象化的重要机制。它允许一个类（子类）从另一个类（超类、基类、父类）继承特性，包括方法和字段。继承使得子类能够获取父类的功能，同时还能...
package-and-inheritance.zip_inheritance
09-24
4. **集合框架**：Java提供了丰富的集合框架，包括List、Set、Queue和Map等接口，以及ArrayList、HashSet、LinkedList等实现类，方便地管理和操作数据。 5. **泛型**：泛型是一种强大的工具，用于在编译时检查类型...
EC.zip_eC_inheritance
09-21
How do you choose between inheritance and templates? Between templates and generic pointers? Between public and private inheritance? Between private inheritance and layering? Between function ...
Chapter7_Java_Inheritance.rar_inheritance
09-21
这个概念是第7章“Java继承”中重点讲解的内容。通过继承，我们可以创建具有共同特性的类群，减少代码的重复，提高代码的复用性和可维护性。 继承的基本语法是使用关键字`extends`，例如： ```java public class ...
ILRuntime的JsonFx,支持在热更新层使用支持接口
11-29
可以在ILRuntime层工作的json序列化工具,这个代码已经在一个较大的项目中使用. 为什么要hot层?因为要支持自定义converter 因为有了自定义converter就能完整的保存整个类对象. 这里包括字典序列化\枚举列表\接口类型等等 有了它,你就能完整保存游戏了. 目前只支持字段序列化.属性需要自行打开注释掉的代码 [JsonIgnore], [JsonName("youname")] //避免代码混淆无法读取 ThingJsonConverter 为接口类型例子,接口代码需要自己定义一个同名字段在类里. GetInterfaceOrAbstractClassKeyName
ILRuntime 1.6
06-11
最新版的Unity3D代码热更新，里面有热更新案例 无缝访问C#工程的现成代码，无需额外抽象脚本API 直接使用VS2015进行开发，ILRuntime的解译引擎支持.Net 4.6编译的DLL 执行效率是L#的10-20倍 选择性的CLR绑定使跨域调用更快速，绑定后跨域调用的性能能达到slua的2倍左右（从脚本调用GameObject之类的接口） 支持跨域继承 完整的泛型支持 拥有Visual Studio的调试插件，可以实现真机源码级调试。支持Visual Studio 2015 Update3 以及Visual Studio 2017和Visual Studio 2019
Unity 热更新之ILRuntime（三）
zzzsss123333的博客
04-02 1161
Unity 热更新之ILRuntime（三） 一.ILRuntime跨域继承 如果你想在热更DLL项目当中继承一个Unity主工程里的类，或者实现一个主工程里的接口，你需要在Unity主工程中实现一个继承适配器。 如果不进行处理，那么运行之后将会报错，所以需要进行跨域继承 相关文档 http://ourpalm.github.io/ILRuntime/public/v1/guide/cross-domain.html public class UIBaseAdapter : CrossBindin
ILRuntime技术相关的总结(转)
weixin_33941350的博客
10-22 2113
官方地址 https://ourpalm.github.io/ILRuntime/public/v1/guide/tutorial.html   代码分支: feature/Hotfix_test_RonMacPro_180823 我的测试分支的源码里,直接搜索  RonILRuntime 就能快速找到对应的源码 然后,遇到一些奇怪的问题.我都总结在最后面.这个大家要注意一下   ...
ILRuntime热更新
sugarsama的博客
07-29 1850
ILRuntime自学总结笔记，期望能帮到有缘人少走些弯路。
Unity 热更新方案之——ILRuntime
qq_41044598的博客
08-12 7900
unity热更新方案：ILRuntime
Unity热更新之ILRuntime
04-15
ILRuntime项目为基于C#的平台（例如Unity）提供了一个纯C#实现，快速、方便且可靠的IL运行时，使得能够在不支持JIT的硬件环境（如iOS）能够实现代码的热更新ILRuntime的优势同市面上的其他热更方案相比，ILRuntime主要有以下优点：无缝访问C#工程的现成代码，无需额外抽象脚本API直接使用VS2015进行开发，ILRuntime的解译引擎支持.Net 4.6编译的DLL执行效率是L#的10-20倍选择性的CLR绑定使跨域调用更快速，绑定后跨域调用的性能能达到slua的2倍左右（从脚本调用GameObject之类的接口）支持跨域继承完整的泛型支持拥有Visual Studio的调试插件，可以实现真机源码级调试。支持Visual Studio 2015 Update3 以及Visual Studio 2017_____________________________________________________________________________________________________________本课程带领大家极速的上手ILRuntime中,让大家学会在Unity如何快速集成ILRuntime热更新技术~
ILRuntime热更案例学习(四) ------ Coroutine/MonoBehaviour/LitJson
千喜
12-12 3677
官方示例下载地址1: https://github.com/Ourpalm/ILRuntime 官方示例下载地址2 : https://github.com/Ourpalm/ILRuntimeU3D 官方文档地址 : https://ourpalm.github.io/ILRuntime/public/v1/guide/tutorial.html 一.Coroutine案例 此案例向我们展...
ILRuntime第一课HelloWorld
YE_wolf的博客
08-07 4536
1.环境配置 a).导入热更需要的文件夹 ILRuntime Mono.Cecil.20 Mono.Cecil.Pdb b)设置不安全模式 在Assets目录里建立一个名为smcs.rsp的文本文件 在smcs.rsp文件中加入 -unsafe 如果你使用的是Unity5.5以上的版本，你需要将上述说明中的smcs.rsp文件名改成mcs
java Inheritance
最新发布
04-27
Java Inheritance is a mechanism where a new class is derived from an existing class. The existing class is called the parent class or the superclass, and the new class is called the child class or the subclass. The child class inherits all the properties and methods of the parent class, and it can also define its own properties and methods. In Java, inheritance is achieved through the use of the "extends" keyword. When a class extends another class, it inherits all the public and protected members of the parent class. The child class can then use these members as if they were its own. Java supports single inheritance, which means that a class can only inherit from one parent class. However, Java also supports interface inheritance, where a class can implement multiple interfaces. The interfaces define a set of methods that the implementing class must implement. Inheritance is an important concept in object-oriented programming, as it promotes code reuse and allows for the creation of complex class hierarchies.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值