xLua——C#扩展方法与xLua泛型

作者：追风剑情发布于：2017-7-19 21:20 分类：Lua

以下代码来自xLua demo

using System;
using System.IO;
using System.Collections.Generic;
using UnityEngine;
using XLua;
 
[LuaCallCSharp]
public class Foo1Parent
{
}
 
[LuaCallCSharp]
public class Foo2Parent
{
}
 
[LuaCallCSharp]
public class Foo1Child : Foo1Parent
{
}
 
[LuaCallCSharp]
public class Foo2Child : Foo2Parent
{
}
 
[LuaCallCSharp]
public class Foo
{
    #region Supported methods
 
    public void Test1<T>(T a) where T : Foo1Parent
    {
        Debug.Log(string.Format("Test1<{0}>", typeof (T)));
    }
 
    public T1 Test2<T1, T2>(T1 a, T2 b, GameObject c) where T1 : Foo1Parent where T2 : Foo2Parent
    {
        Debug.Log(string.Format("Test2<{0},{1}>", typeof (T1), typeof (T2)), c);
        return a;
    }
 
    #endregion
 
    #region Unsupported methods
 
    /// <summary>
    /// 不支持生成lua的泛型方法（没有泛型约束）
    /// </summary>
    public void UnsupportedMethod1<T>(T a)
    {
        Debug.Log("UnsupportedMethod1");
    }
 
    /// <summary>
    /// 不支持生成lua的泛型方法（缺少带约束的泛型参数）
    /// </summary>
    public void UnsupportedMethod2<T>() where T : Foo1Parent
    {
        Debug.Log(string.Format("UnsupportedMethod2<{0}>",typeof(T)));
    }
 
    /// <summary>
    /// 不支持生成lua的泛型方法（泛型约束必须为class）
    /// </summary>
    public void UnsupportedMethod3<T>(T a) where T : IDisposable
    {
        Debug.Log(string.Format("UnsupportedMethod3<{0}>", typeof(T)));
    }
 
    #endregion
}
 
[LuaCallCSharp]
public static class FooExtension
{
    public static void PlainExtension(this Foo1Parent a)
    {
        Debug.Log("PlainExtension");
    }
 
    public static T Extension1<T>(this T a) where T : Foo1Parent
    {
        Debug.Log(string.Format("Extension1<{0}>", typeof (T)));
        return a;
    }
 
    public static T Extension2<T>(this T a, GameObject b) where T : Foo1Parent
    {
        Debug.Log(string.Format("Extension2<{0}>", typeof (T)), b);
        return a;
    }
 
    public static void Extension2<T1, T2>(this T1 a, T2 b) where T1 : Foo1Parent where T2 : Foo2Parent
    {
        Debug.Log(string.Format("Extension2<{0},{1}>", typeof (T1), typeof (T2)));
    }
 
    public static T UnsupportedExtension<T>(this GameObject obj) where T : Component
    {
        return obj.GetComponent<T>();
    }
}

using UnityEngine;
using XLua;
 
public class GenericMethodExample : MonoBehaviour
{
    private const string script = @"
        local foo1 = CS.Foo1Child()
        local foo2 = CS.Foo2Child()
 
        local obj = CS.UnityEngine.GameObject()
        foo1:PlainExtension()
        foo1:Extension1()
        foo1:Extension2(obj) -- overload1
        foo1:Extension2(foo2) -- overload2
        
        local foo = CS.Foo()
        foo:Test1(foo1)
        foo:Test2(foo1,foo2,obj)
";
    private LuaEnv env;
 
    private void Start()
    {
        env = new LuaEnv();
        env.DoString(script);
    }
 
    private void Update()
    {
        if (env != null)
            env.Tick();
    }
 
    private void OnDestroy()
    {
        env.Dispose();
    }
}