在进行lua方法注册的时候, 大多数解决方案直接否定了泛型方法, 因为在lua侧难以表达出泛型, 以及lua的函数重载问题,

函数重载问题可以通过一些特殊方法解决, 而泛型问题是主要问题, 以Unity + Slua的情况来说

比如下面的类:

  1. public class Foo
  2. {
  3. public static void GetTypeName(System.Type type)
  4. {
  5. Debug.Log(type.Name);
  6. }
  7. public static void GetTypeName<T>()
  8. {
  9. Debug.Log(typeof(T).Name);
  10. }
  11. }

一般只会生成  GetTypeName(System.Type type) 的注册方法.

那么泛型的方法在Lua那边该怎样注册才能让这个调用能够实现呢? 一般来说我们调用泛型方法必须在写代码的时候就确定, 像这样:

  1. Foo.GetTypeName<int>();  // 输出 Int32

而lua并不能这样约束, 它的调用必须还是非泛型的才可以, 这是第一个问题, 而第二个问题是lua那边怎样写? 我们希望它的写法能跟C#保持

一致, 或者相似吧, 让人看起来容易明白, 可是lua中中括号是大于小于号, 不能这样写, 想想有没有什么办法

因为在lua中是没有类型的, 类型必须来自C#, 所以只能将泛型作为非泛型方法才能使用, 如果让函数进行一次退化和封装, 像下面这样

  1. -- 先将C# 的typeof注册成全局函数, 注册System.Int32命名为int
  2. local Foo = {}
  3. Foo.GetTypeName = function(type)
  4. return function()
  5. print(type.Name)
  6. end
  7. end
  1. Foo.GetTypeName(typeof(int))();  -- lua
  1. Foo.GetTypeName<int>();  // C#  -- 之前写错了 -_-!
  2.  
  3. 这样写的话, 除了尖括号, 基本就能两边一致了对吧, 运行结果也是一样的
  1. /*至于怎样注册typeof(int)*/
  1. // 在LuaState的Init中注册个全局函数
    [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  2. internal static int getType(IntPtr L)
  3. {
  4.   System.Type type = null;
  5.   LuaObject.checkType(L, , out type);
  6.   LuaObject.pushObject(L, type);
  7.   return ;
  8. }
  1. // 在LuaState的Init中自己注册咯
    LuaDLL.lua_pushcfunction(L, getType);
    LuaDLL.lua_setglobal(L, "typeof");
  1. // CustomExport.OnAddCustomClass 中添加类型别名
  2. add(typeof(System.Int32), "int"); // int

只是这里lua的函数没有进行C#那边的调用啊, 下一步就来看看有没有什么办法来实现调用.

如果通过自动注册的话, Foo应该是一个已经注册的类型.

  1. [SLua.CustomLuaClass]
  2. public class Foo

并且有元表, 元表里面有非泛型的GetTypeName方法了. 现在先不要去动元表,

直接注册这个到Table里面, 因为如果Table里面有值的话, 就不会去查询元表了

  1. import "Foo";
  2. Foo.GetTypeName(typeof(int));  // 输出 Int32
  3.  
  4. rawset(Foo, "GetTypeName", function(type)
  5. return function()
  6. local mt = getmetatable(Foo)
  7. local func = rawget(mt,"GetTypeName");
  8. func(type)
  9. end
  10. end)
  11.  
  12. Foo.GetTypeName(typeof(int))();  // 输出 Int32 -- 注意返回了function然后再次调用

这个方法比较流氓, 因为直接默认了有非泛型函数, 并且覆盖了元表的非泛型方法, 不可取的.

要继续的话, 首先来看看一个泛型方法怎样通过非泛型(Type)方法进行调用的:

  1. var methods = typeof(Foo).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod);
  2. foreach(var method in methods)
  3. {
  4. if(method.IsGenericMethod)
  5. {
  6. var paramters = method.GetParameters();
  7. if(paramters == null || paramters.Length == )
  8. {
  9. var genericMethod = method.MakeGenericMethod(new Type[] { typeof(int) });
  10. if(genericMethod != null)
  11. {
  12. genericMethod.Invoke(null, null);  // 输出 Int32
                  break;
    }
  13. }
  14. }
  15. }

当然是反射啦, 这样就能让泛型方法退化为非泛型了, 虽然是一个缓慢的反射, 不过时间基本只花费在Invoke上, 问题还不大.

剩下的问题是重载了, 有非泛型和泛型的两个同名函数, 为了测试我先删除掉非泛型,

  1. [SLua.CustomLuaClass]
  2. public class Foo
  3. {
  4. //public static void GetTypeName(System.Type type)
  5. //{
  6. // Debug.Log(type.Name);
  7. //}
  8. public static void GetTypeName<T>()
  9. {
  10. Debug.Log(typeof(T).Name);
  11. }
  12. }

生成的lua注册代码也要修改一下 (自动生成的注册类文件名应该是Lua_Foo.cs 吧)

  1. System.Type a1;
  2. checkType(l,,out a1);
  3. Foo.GetTypeName(a1); // 泛型函数被注释了
  4. pushValue(l,true);

改成

  1. System.Type a1;
  2. checkType(l,,out a1);
  3. var methods = typeof(Foo).GetMethods(System.Reflection. BindingFlags.Public
  4. | System.Reflection.BindingFlags.Static
  5. | System.Reflection.BindingFlags.InvokeMethod);
  6. foreach(var method in methods)
  7. {
  8. if(method.IsGenericMethod)
  9. {
  10. var paramters = method.GetParameters();
  11. if(paramters == null || paramters.Length == )
  12. {
  13. var genericMethod = method.MakeGenericMethod(new Type[] { typeof(int) });
  14. if(genericMethod != null)
  15. {
  16. genericMethod.Invoke(null, null);
  17. break;
  18. }
  19. }
  20. }
  21. }
  22. pushValue(l,true);

试试运行一下看看, 输出 Int32 看来没有问题, 问题是在Lua那边还是需要手动封装了一遍, 看前文:

  1. -- 问题是, 不进行一次rawset无法得到泛型写法
  2. Foo.GetTypeName(typeof(int))();  // 输出 Int32 -- Table方法

到这里, 基本就可以得出结论了,

一. 在lua中可以通过封装(闭包)的方式接近C#的泛型的写法, 差别只是一个中括号和小括号

  1. Foo.GetTypeName(typeof(int))();  -- lua  我们可以把 lua全局变量int 赋值为 typeof(int), 这样可以跟C#更加相似:
    int = typeof(int);
  2.  
  3. Foo.GetTypeName(int)();
  1. Foo.GetTypeName<int>();  // C# -- 之前写错了 -_-!

然而过程异常复杂, 比如上述代码中的rawset过程需要在C#的注册代码中进行实现, 而在调用的地方需要通过反射, 并且在lua侧需要解决函数重载的问题,

上面的例子直接做了覆盖. 就无法正常访问非泛型方法函数了, 是个错误方向.

PS: 今天又看了一遍这篇文章, 这里有点歧义, 其实是在lua这边不需要实现重载, 重载方法的调用是由C#那边的注册代码封装的.

  而我这里手动覆盖了lua这边的Foo的GetTypeName方法(该方法原来由metatable提供, 现在我在Foo里面直接添加了GetTypeName).

二. 既然泛型方法可以退化为非泛型, 那么可以直接检测有没有同名的且同参数的非泛型函数, 如果没有就把泛型方法的非泛型版添加到注册函数中即可.

Slua是通过反射程序集来查找相应类型然后通过反射里面的对象来实现注册代码生成的, 这里我想到一个丧心病狂的方法, 就是通过ILGenerator和Emit的方式,

把泛型方法转换成非泛型方法, 添加到IL代码里面, 这样在编辑器下的反射就可以自动生成一个非泛型的对应函数了哈哈哈哈哈哈......想想工作量真够大的.

先封装一下非泛型调用泛型方法的逻辑:

  1. // 反射调用泛型函数方法
  2. public static void CallGenericFunction(System.Type type, string genericFuncName, object instance, Type[] genericTypes, object[] paramaters, bool isStatic)
  3. {
  4. var flags = BindingFlags.Public | BindingFlags.NonPublic | (isStatic ? BindingFlags.Static : BindingFlags.Instance) | BindingFlags.InvokeMethod;
  5. var methods = typeof(Foo).GetMethods(flags);
  6. foreach(var method in methods)
  7. {
  8. if(method.IsGenericMethod && string.Equals(method.Name, genericFuncName, StringComparison.Ordinal))
  9. {
  10. var arguments = method.GetGenericArguments(); // 检查泛型类的数量是否对的上
  11. if(arguments != null && arguments.Length == genericTypes.Length)
  12. {
  13. // 检查传入参数类型是否对的上, 如果考虑到可变参数, default value参数, 可空结构体参数等, 会很复杂
  14. if(MethodParametersTypeEquals(method, paramaters))
  15. {
  16. var genericMethod = method.MakeGenericMethod(genericTypes);
  17. if(genericMethod != null)
  18. {
  19. genericMethod.Invoke(instance, paramaters);
  20. break;
  21. }
  22. }
  23. }
  24. }
  25. }
  26. }
  27. // 简单的对比一下, 实际使用要考虑到可变参数( params object[] ), default value参数( bool isStatic = false ), 可空结构体参数( int? a = null )等
  28. public static bool MethodParametersTypeEquals(MethodInfo method, object[] parameters)
  29. {
  30. var mehotdParamters = method.GetParameters();
  31. int len_l = mehotdParamters != null ? mehotdParamters.Length : ;
  32. int len_r = parameters != null ? parameters.Length : ;
  33. return len_l == len_r;
  34. }

测试一下, 为了测试非静态函数, 添加了非静态一个方法

  1. [SLua.CustomLuaClass]
  2. public class Foo
  3. {
  4. public static void GetTypeName(System.Type type)
  5. {
  6. Debug.Log(type.Name);
  7. }
  8. public static void GetTypeName<T>()
  9. {
  10. Debug.Log(typeof(T).Name);
  11. }
  12. public void TypeName<T>()
  13. {
  14. Debug.Log(typeof(T).Name);
  15. }
  16. }
  1. CallGenericFunction(typeof(Foo), "GetTypeName", null, new Type[] { typeof(float) }, null, true);  // 输出 Single
  2. var foo = new Foo();
  3. CallGenericFunction(typeof(Foo), "TypeName", foo, new Type[] { typeof(int) }, null, false);    // 输出 Int32

调用是正确的.

写了这个调用封装之后, 我发现有两种路线可以进行下去, 第一个就是前面提到的Emit(只在编辑器下使用, 可以放心), 另一个方法是修改Slua的生成代码的逻辑,

先说修改Slua的生成代码那方面, 上面的Foo生成的GetTypeName的注册函数如下 :

  1. [SLua.MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  2. [UnityEngine.Scripting.Preserve]
  3. static public int GetTypeName_s(IntPtr l)
  4. {
  5. try
  6. {
  7. System.Type a1;
  8. checkType(l, , out a1);
  9. Foo.GetTypeName(a1);
  10. pushValue(l, true);
  11. return ;
  12. }
  13. catch(Exception e)
  14. {
  15. return error(l, e);
  16. }
  17. }// 删了一些头头尾尾

如果没有非泛型方法GetTypeName(System.Type type), 它是不会有这个注册函数的, 我们先直接改这里:

  1. //Foo.GetTypeName(a1);
  2. Test.CallGenericFunction(typeof(Foo), "GetTypeName", null, new Type[] { a1 }, null, true);  // 直接调用换成了封装的调用, 函数放在一个Test类里面

lua调用进入这里, 注意这里是非泛型方法的入口, 我改了C#那边把调用转到了泛型方法

  1. import "Foo";
  2.  
  3. Foo.GetTypeName(typeof(int));  // 输出 Int32

正确的, 那么应该修改的生成代码逻辑在 LuaCodeGen.cs 里面, 具体就不测试了, 逻辑就改为在反射获取泛型方法之后, 将泛型方法跟非泛型做对比, 然后采取合并之类的逻辑进行代码生成. 这个就看自己的控制逻辑了,

因为退化后的泛型跟非泛型同名同然而逻辑不同的情况是存在的, 如果逻辑不同的话, 就麻烦了...

  1. public static void GetTypeName(System.Type type); // 逻辑1
  2. public static void GetTypeName<T>();// 退化->GetTypeName(System.Type type) 逻辑2

在只有GetTypeName<T>()方法时, 那就像上图的生成代码替换掉Foo.GetTypeName(a1) 为 Test.CallGenericFunction(typeof(Foo), ...) 即可.

两个方法都有时, 任选其一即可. 当然存在函数重载的实现也在这里进行即可, 原来的函数重载就是在这实现的.

第二种: 把泛型方法转换成非泛型然后添加到原有类型中, ILGenerator 太复杂, 写个例子就行了, 再见!!!

PS: 这个使用方法不能对已经存在的类型进行修改, 是创建了一个类型, 当然我们可以把有泛型的类型生成一个新的类型来用非泛型代替泛型, 然后利用lua实现多重继承或者强行注册的方式实现最终的整合.

然而, 创建新类型去调用原有类型的泛型方法, 不是静态的需要传递实例作为参数, 然后在自动生成代码处自动封装, 这些逻辑会复杂上天了.

  1. public class Test{
  2. public static System.Type TestILGenerator()
  3. {
  4. const string funcName = "SayHello";
  5. //构建程序集
  6. var asmName = new AssemblyName("Test");
  7. var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
  8.  
  9. //构建模块
  10. var mdlBldr = asmBuilder.DefineDynamicModule("Main", "Main.dll");
  11.  
  12. //构建类
  13. var typeBldr = mdlBldr.DefineType("Hello", TypeAttributes.Public);
  14.  
  15. //构建方法
  16. var methodBldr = typeBldr.DefineMethod(
  17. funcName,
  18. MethodAttributes.Public | MethodAttributes.Static,
  19. null,//return type
  20. null//parameter type
  21. );
  22. //IL构建底层细节
  23. var il = methodBldr.GetILGenerator();//获取il生成器
  24. il.Emit(OpCodes.Ldstr, "Hello, World");
  25. il.Emit(OpCodes.Call, typeof(UnityEngine.Debug).GetMethod("Log", new Type[] { typeof(string) }));
  26. il.Emit(OpCodes.Ret);
  27.  
  28. //完成构建
  29. var t = typeBldr.CreateType();
  30. t.GetMethod(funcName).Invoke(null, null);  // 输出 Hello, World
  31. return t;
  32. }
  33. }

我在这里测试了一下, 创建类型Hello以及设置静态函数SayHello都是成功了的, 这样就欺骗了编译器认为这个类型存在了, 用LuaCodeGen也能强行生成注册类函数:

  1. [MenuItem("SLua/Custom/Make2")]  // 强行搞一个代码创建
  2. static public void Custom2()
  3. {
  4. List<Type> exports = new List<Type>();
  5. string path = GenPath + "Custom/";
  6. ExportGenericDelegate fun = (Type t, string ns) =>
  7. {
  8. if(Generate(t, ns, path))
  9. exports.Add(t);
  10. };
  11.  
  12. var myType = Test.TestILGenerator();
  13. fun(myType, null);
  14. }

生成出的代码就懵逼了哈哈, 在生成的时候骗了编译器, 生成之后是骗不了人的, 下面的生成的Lua_Hello.cs 文件.

  1. [UnityEngine.Scripting.Preserve]
  2. public class Lua_Hello : LuaObject {
  3. [SLua.MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  4. [UnityEngine.Scripting.Preserve]
  5. static public int constructor(IntPtr l) {
  6. try {
  7. Hello o;
  8. o=new Hello();  // 注意这里编译错误, 因为没有实体的类型, 编译器无法找到Hello类
  9. pushValue(l,true);
  10. pushValue(l,o);
  11. return ;
  12. }
  13. catch(Exception e) {
  14. return error(l,e);
  15. }
  16. }
  17. [SLua.MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  18. [UnityEngine.Scripting.Preserve]
  19. static public int SayHello_s(IntPtr l) {
  20. try {
  21. Hello.SayHello();
  22. pushValue(l,true);
  23. return ;
  24. }
  25. catch(Exception e) {
  26. return error(l,e);
  27. }
  28. }
  29. [UnityEngine.Scripting.Preserve]
  30. static public void reg(IntPtr l) {
  31. getTypeTable(l,"Hello");
  32. addMember(l,SayHello_s);
  33. createTypeMetatable(l,constructor, typeof(Hello));
  34. }
  35. }

这种方法到这里基本上就是死刑了, 可是还可以抢救一下, 就是在运行时进行类型的生成, 然后Lua注册代码, 也就是Lua_Hello.cs里面这些, 也在运行时生成, 然后完成运行时的注册行为...

恩...所以说来说去, 最方便的还是在C#中写上非泛型方法最方便了, 本文也是突发奇想研究弄一下泛型方法在lua中的自动注册问题.

这里的简单例子中泛型和非泛型没有严格的使用限制, 所以可以在C#中两种都写, 实际情况可能有些情况写不了非泛型的情况也有, 这种情况下通过lua调用CallGenericFunction方法来调用泛型方法反而比自动注册简单多了...

脱裤子放屁的事情就别做了, 直接调反射吧.

补充(2019.04.16):

  1. MakeGenericMethod 这个方法在AOT编译下能不能使用还不清楚, 因为类型不确定的时候是在运行时生成类型, 比如泛型类在运行时生成就不行,
    比如 AA<T> 这个泛型类, 使用 typeof(AA<>).MakeGenericType(typeof(int)); 就不行, 需要后续测试
  1.  

一种C#泛型方法在lua中表示的设计的更多相关文章

  1. lua中for循环的四种遍历方式

    lua中for的四种遍历方式区别 table.maxn 取最大的整数key #table 从1开始的顺序整数最大值,如1,2,3,6 #table == 3   key,value pairs 取每一 ...

  2. Lua中使用table实现的其它5种数据结构

    Lua中使用table实现的其它5种数据结构 lua中的table不是一种简单的数据结构,它可以作为其他数据结构的基础,如:数组,记录,链表,队列等都可以用它来表示. 1.数组 在lua中,table ...

  3. lua中遍历table的几种方式比较

    当我在工作中使用lua进行开发时,发现在lua中有4种方式遍历一个table,当然,从本质上来说其实都一样,只是形式不同,这四种方式分别是: for key, value in pairs(tbtes ...

  4. lua中,两种json和table互转方法的效率比较

    lua中json和table的互转,是我们在平时开发过程中经常用到的.比如: 在用lua编写的服务器中,如果客户端发送json格式的数据,那么在lua处理业务逻辑的时候,必然需要转换成lua自己的数据 ...

  5. lua中基类和“继承机制”

    基类:基类定义了所有对于派生类来说普通的属性和方法,派生类从基类继承所需的属性和方法,且在派生类中增加新的属性和方法. 继承:继承是C++语言的一种重要机制,它允许在已定义的类的基础上产生新类. lu ...

  6. lua中的table、stack和registery

    ok,前面准备给一个dll写wrapper,写了篇日志,看似写的比较明白了,但是其实有很多米有弄明白的.比如PIL中使用的element,key,tname,field这些,还是比较容易混淆的.今天正 ...

  7. lua 中的面向对象

    lua 是一种脚步语言,语言本身并不具备面向对象的特性. 但是我们依然可以利用语言的特性,模拟出面向对象的特性. 面向对象的特性通常会具备:封装,继承,多态的特性,如何在lua中实现这些特性,最主要的 ...

  8. Lua中的weak表——weak table

    弱表(weak table)是一个很有意思的东西,像C++/Java等语言是没有的.弱表的定义是:A weak table is a table whose elements are weak ref ...

  9. Lua中的协同程序 coroutine

    Lua中的协程和多线程很相似,每一个协程有自己的堆栈,自己的局部变量,可以通过yield-resume实现在协程间的切换.不同之处是:Lua协程是非抢占式的多线程,必须手动在不同的协程间切换,且同一时 ...

随机推荐

  1. Java MySQL数据类型对照

    Java MySQL数据类型对照 类型名称 显示长度 数据库类型 JAVA类型 JDBC类型索引(int) 描述             varchar L+N VARCHAR java.lang.S ...

  2. django复习-3-请求与响应

    一.请求request 前端向后端传递参数有几种方式? 提取URL的特定部分,如/weather/beijing/2018,可以在服务器端的路由中用正则表达式截取: "http://127. ...

  3. 《JavaScript高级程序设计》读书笔记--ECMAScript中所有函数的参数都是按值传递的

    ECMAScript中所有函数的参数都是按值传递的.也就是说把函数外部的值复制给函数内部的参数(内部参数的值的修改不影响实参的值). 基本类型变量的复制: 基本类型变量的复制,仅仅是值复制,num1和 ...

  4. MongoDB3.2配置文件.md

    Core Options systemLog Options systemLog: verbosity: <int> quiet: <boolean> traceAllExce ...

  5. 6、JUC--同步锁Lock

    显示锁 Lock  在Java 5.0之前,协调共享对象的访问时可以使用的机 制只有 synchronized 和 volatile .Java 5.0 后增加了一些 新的机制,但并不是一种替代内置 ...

  6. ubuntu16.04下的htk安装编译

    HTK(HMM Tools Kit)是一个剑桥大学开发的专门用于建立和处理HMM的实验工具包[1],主要应用于语音识别领域,也可以应用于语音合成.字符识别和DNA排序等领域.HTK经过剑桥大学.Ent ...

  7. Leetcode——121. 买卖股票的最佳时机

    题目描述:买卖股票的最佳时机 题目要求求解能获得最大利润的方式? 可以定一个二维数组 d [ len ] [ 2 ] ,其中d[ i ][ 0 ] 表示前i天可以获得的最大利润:d[ i ][ 1 ] ...

  8. Android分享到微信和朋友圈的工具类

    1.只要填写上正确的app_id,且引用上该工具类你就能实现分享到朋友圈和分享到微信. 2.需要到微信平台下载jar包,以及注册一个appid import android.content.Conte ...

  9. odoo之自动生成编号问题

    单独的seq.xml文件 <?xml version="1.0" encoding="utf-8"?><openerp> <dat ...

  10. 详细解读大数据分析引擎Pig&PigLatin语句

    Pig 一.Pig的介绍: Pig由Yahoo开发,主要应用于数据分析,Twitter公司大量使用Pig处理海量数据,Pig之所以是数据分析引擎,是因为Pig相当于一个翻译器,将PigLatin语句翻 ...