public SharpClass RegMethod(string name, MethodBase[] methodInfo, bool isAsync = false)
{
MethodReflection method = new MethodReflection(methodInfo);
#if !IL2CPP
for (int i = 0; i < methodInfo.Length; i++)
{
var mi = methodInfo[i] as MethodInfo;
if (mi != null)
{
if (DelegateCache.GetMethodDelegate(classType, mi, "CallDel", out CallDel fn, out Delegate del))
{
method.luaFunc[i] = fn;
method.del[i] = del;
}
}
}
#endif
//Luna.Log("反射方式实现");
LuaRef luaFun = LuaRef.CreateFunction(State, MethodReflection.Call, method);
if (IsTagMethod(name, out var tag))
{
meta.RawSet(tag, luaFun);
}
else
{
meta.RawSet(name, luaFun);
}
if (classType.IsArray)
{
if (name == "Get")
{
SetMemberFunction(LunaNative.___get_indexed, luaFun);
}
if (name == "Set")
{
SetMemberFunction(LunaNative.___set_indexed, luaFun);
}
}
if (isAsync)
{
LuaRef r = new LuaRef(State, "coroutine.__async");
luaFun = r.Call <LuaRef>(luaFun);
meta.RawSet("_async_" + name, luaFun);
}
return(this);
}
public LuaRef RegMethod(MethodInfo methodInfo, bool isProp)
{
#if LUNA_SCRIPT
string callFnName = (methodInfo.IsStatic && !isProp) ? "StaticCall" : "Call";
#else
string callFnName = "Call";
#endif
if (DelegateCache.GetMethodDelegate(classType, methodInfo, callFnName, out LuaNativeFunction luaFunc, out Delegate del))
{
return(LuaRef.CreateFunction(State, luaFunc, del));
}
return(null);
}
public SharpClass RegField(FieldInfo fieldInfo)
{
if (classInfo.TryGetValue(fieldInfo.Name, out var methodConfig))
{
if (methodConfig.getter != null)
{
var getter = LuaRef.CreateFunction(State, methodConfig.getter);
SetGetter(fieldInfo.Name, getter);
}
if (methodConfig.setter != null)
{
var setter = LuaRef.CreateFunction(State, methodConfig.setter);
SetSetter(fieldInfo.Name, setter);
}
else
{
SetReadOnly(fieldInfo.Name);
}
return(this);
}
//Luna.LogWarning("注册反射版的field : " + fieldInfo.Name);
if (fieldInfo.IsStatic)
{
var getter = LuaRef.CreateFunction(State, Field.StaticGetter, fieldInfo);
SetGetter(fieldInfo.Name, getter);
var setter = LuaRef.CreateFunction(State, Field.StaticSetter, fieldInfo);
SetSetter(fieldInfo.Name, setter);
}
else
{
var getter = LuaRef.CreateFunction(State, Field.Getter, fieldInfo);
SetGetter(fieldInfo.Name, getter);
var setter = LuaRef.CreateFunction(State, Field.Setter, fieldInfo);
SetSetter(fieldInfo.Name, setter);
}
return(this);
}
public SharpClass RegProperty(PropertyInfo propertyInfo, bool isIndexer = false)
{
if (classInfo.TryGetValue(propertyInfo.Name, out var methodConfig))
{
if (methodConfig.getter != null)
{
var getter = LuaRef.CreateFunction(State, methodConfig.getter);
SetGetter(propertyInfo.Name, getter);
}
if (methodConfig.setter != null)
{
var setter = LuaRef.CreateFunction(State, methodConfig.setter);
SetSetter(propertyInfo.Name, setter);
}
else
{
SetReadOnly(propertyInfo.Name);
}
return(this);
}
if (propertyInfo.CanRead)
{
MethodInfo methodInfo = propertyInfo.GetGetMethod(false);
if (methodInfo != null)
{
#if true//IL2CPP
var fn = methodInfo.IsStatic ? (LuaNativeFunction)Property.StaticGetter : Property.Getter;
var getter = LuaRef.CreateFunction(State, fn, propertyInfo);
SetGetter(propertyInfo.Name, getter);
#else
var luaFun = RegMethod(methodInfo, true);
if (luaFun)
{
SetGetter(propertyInfo.Name, luaFun);
}
#endif
}
}
if (propertyInfo.CanWrite)
{
MethodInfo methodInfo = propertyInfo.GetSetMethod(false);
if (methodInfo != null)
{
#if true//IL2CPP
var fn = methodInfo.IsStatic ? (LuaNativeFunction)Property.StaticSetter : Property.Setter;
var setter = LuaRef.CreateFunction(State, fn, propertyInfo);
SetSetter(propertyInfo.Name, setter);
#else
var luaFun = RegMethod(methodInfo, true);
if (luaFun)
{
SetSetter(propertyInfo.Name, luaFun);
}
#endif
}
}
else
{
SetReadOnly(propertyInfo.Name);
}
return(this);
}
public void OnRegClass()
{
var fields = classType.GetFields();
foreach (var field in fields)
{
if (!field.IsPublic)
{
continue;
}
if (field.IsLiteral)
{
RegConstant(field);
}
else
{
RegField(field);
}
}
if (classInfo.TryGetValue("ctor", out var methodConfig))
{
meta.RawSet("__call", LuaRef.CreateFunction(State, methodConfig.func));
}
else
{
var ctors = classType.GetConstructors();
List <MethodBase> memberInfo = new List <MethodBase>();
foreach (var constructorInfo in ctors)
{
if (!constructorInfo.IsPublic)
{
continue;
}
if (!constructorInfo.ShouldExport())
{
continue;
}
var paramInfos = constructorInfo.GetParameters();
foreach (var info in paramInfos)
{
if (!info.ParameterType.ShouldExport())
{
continue;
}
}
memberInfo.Add(constructorInfo);
}
if (memberInfo.Count > 0)
{
RegMethod("__call", memberInfo.ToArray());
}
}
var props = classType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
foreach (var p in props)
{
if (!p.ShouldExport())
{
continue;
}
RegProperty(p);
}
var methods = classType.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
HashSet <string> registered = new HashSet <string>();
foreach (var m in methods)
{
if (registered.Contains(m.Name))
{
continue;
}
bool isAsync = m.GetCustomAttribute <LuaAsyncAttribute>() != null;
if (classInfo.TryGetValue(m.Name, out methodConfig))
{
if (methodConfig.func != null)
{
var fn = LuaRef.CreateFunction(State, methodConfig.func);
if (IsTagMethod(m.Name, out var tag))
{
meta.RawSet(tag, fn);
}
else
{
meta.RawSet(m.Name, fn);
}
if (isAsync)
{
LuaRef r = new LuaRef(State, "coroutine.__async");
fn = r.Call <LuaRef>(fn);
meta.RawSet("_async_" + m.Name, fn);
}
if (classType.IsArray)
{
if (m.Name == "Get")
{
SetMemberFunction(LunaNative.___get_indexed, fn);
}
if (m.Name == "Set")
{
SetMemberFunction(LunaNative.___set_indexed, fn);
}
}
}
registered.Add(m.Name);
continue;
}
if (!m.ShouldExport())
{
continue;
}
var memberInfo = classType.GetMember(m.Name).Cast <MethodBase>().ToArray();
registered.Add(m.Name);
if (memberInfo.Length > 0)
{
RegMethod(m.Name, memberInfo, isAsync);
}
}
}