public virtual IProxyMethodInfo GetMethod(string name, Type[] parameterTypes)
{
IProxyMethodInfo info = this.GetMethodInfo(name, parameterTypes);
if (info != null)
{
return(info);
}
MethodInfo methodInfo = this.type.GetMethod(name, parameterTypes);
if (methodInfo != null && methodInfo.DeclaringType.Equals(type))
{
return(this.CreateProxyMethodInfo(methodInfo));
}
IProxyType baseTypeInfo = this.GetBase();
if (baseTypeInfo == null)
{
return(null);
}
return(baseTypeInfo.GetMethod(name, parameterTypes));
}
public static IProxyInvoker AsProxy(this MethodInfo info, object target)
{
IProxyType proxyType = factory.Create(info.DeclaringType);
IProxyMethodInfo proxyMethodInfo = proxyType.GetMethod(info);
return(new ProxyInvoker(target, proxyMethodInfo));
}
public IProxyMethodInfo GetMethod(string name, Type[] parameterTypes, BindingFlags flags)
{
IProxyMethodInfo info = this.GetMethodInfo(name, parameterTypes);
if (info != null)
{
return(info);
}
#if NETFX_CORE
MethodInfo methodInfo = this.type.GetMethod(name, flags);
#else
MethodInfo methodInfo = this.type.GetMethod(name, flags, null, parameterTypes, null);
#endif
if (methodInfo != null && methodInfo.DeclaringType.Equals(type))
{
return(this.CreateProxyMethodInfo(methodInfo));
}
IProxyType baseTypeInfo = this.GetBase();
if (baseTypeInfo == null)
{
return(null);
}
return(baseTypeInfo.GetMethod(name, parameterTypes, flags));
}
public void Add(IProxyMethodInfo info)
{
if (info == null || info.MethodInfo == null)
{
return;
}
methods[info.MethodInfo] = info;
}
public void Remove(IProxyMethodInfo info)
{
if (info == null || info.MethodInfo == null)
{
return;
}
methods.Remove(info.MethodInfo);
}
public MethodTargetProxy(object target, IProxyMethodInfo methodInfo) : base(target)
{
this.methodInfo = methodInfo;
if (!methodInfo.ReturnType.Equals(typeof(void)))
{
throw new ArgumentException("methodInfo");
}
this.invoker = new WeakProxyInvoker(new WeakReference(target, true), methodInfo);
}
public object Invoke(string name, Type[] parameterTypes, params object[] args)
{
IProxyMethodInfo proxyMethodInfo = this.ProxyType.GetMethod(name, parameterTypes);
if (proxyMethodInfo == null)
{
return(null);
}
return(proxyMethodInfo.Invoke(this.Value, args));
}
public void Register(IProxyMethodInfo info)
{
if (info == null)
{
return;
}
ProxyType proxyType = GetProxyType(info.DeclaringType);
proxyType.Add(info);
}
public virtual IProxyInvoker GetMethodInvoker(string name, Type[] parameterTypes)
{
IProxyMethodInfo proxyMethodInfo = this.ProxyType.GetMethod(name, parameterTypes);
if (proxyMethodInfo == null)
{
throw new InvalidOperationException("Method not found");
}
return(new ProxyInvoker(this.Value, proxyMethodInfo));
}
protected void RemoveMethodInfo(IProxyMethodInfo methodInfo)
{
lock (_lock)
{
string name = methodInfo.Name;
List <IProxyMethodInfo> list;
if (!this.methods.TryGetValue(name, out list))
{
return;
}
list.Remove(methodInfo);
}
}
protected void AddMethodInfo(IProxyMethodInfo methodInfo)
{
lock (_lock)
{
string name = methodInfo.Name;
List <IProxyMethodInfo> list;
if (!this.methods.TryGetValue(name, out list))
{
list = new List <IProxyMethodInfo>();
this.methods.Add(name, list);
}
list.Add(methodInfo);
}
}
protected virtual bool IsValid(IProxyInvoker invoker)
{
IProxyMethodInfo info = invoker.ProxyMethodInfo;
if (!info.ReturnType.Equals(typeof(void)))
{
return(false);
}
ParameterInfo[] parameters = info.Parameters;
// if (parameters == null || parameters.Length != 2)
return(false);
// return parameters[0].ParameterType.IsAssignableFrom(typeof(object)) && parameters[1].ParameterType.IsAssignableFrom(typeof(InteractionEventArgs));
}
protected override bool IsValid(IProxyInvoker invoker)
{
IProxyMethodInfo info = invoker.ProxyMethodInfo;
if (!info.ReturnType.Equals(typeof(void)))
{
return(false);
}
var parameters = info.Parameters;
if (parameters != null && parameters.Length != 0)
{
return(false);
}
return(true);
}
protected virtual bool IsValid(IProxyInvoker invoker)
{
IProxyMethodInfo info = invoker.ProxyMethodInfo;
if (!info.ReturnType.Equals(typeof(void)))
{
return(false);
}
var parameters = info.Parameters;
if (parameters == null || parameters.Length != 1)
{
return(false);
}
return(parameters[0].ParameterType.IsAssignableFrom(typeof(T)));
}
protected bool IsParameterMatch(IProxyMethodInfo proxyMethodInfo, Type[] parameterTypes)
{
ParameterInfo[] parameters = proxyMethodInfo.Parameters;
if ((parameters == null || parameters.Length == 0) && (parameterTypes == null || parameterTypes.Length == 0))
{
return(true);
}
if (parameters != null && parameterTypes != null && parameters.Length == parameters.Length)
{
for (int i = 0; i < parameters.Length; i++)
{
if (!parameters[i].Equals(parameterTypes[i]))
{
return(false);
}
}
return(true);
}
return(false);
}
public WeakProxyInvoker(WeakReference target, IProxyMethodInfo proxyMethodInfo)
{
this.target = target;
this.proxyMethodInfo = proxyMethodInfo;
}
public ProxyInvoker(object target, IProxyMethodInfo proxyMethodInfo)
{
this.target = target;
this.proxyMethodInfo = proxyMethodInfo;
}
protected IProxyMethodInfo CreateProxyMethodInfo(MethodInfo methodInfo)
{
IProxyMethodInfo info = null;
#if UNITY_IOS
info = new ProxyMethodInfo(methodInfo);
#else
try
{
Type returnType = methodInfo.ReturnType;
ParameterInfo[] parameters = methodInfo.GetParameters();
Type type = methodInfo.DeclaringType;
if (typeof(void).Equals(returnType))
{
if (methodInfo.IsStatic)
{
if (parameters == null || parameters.Length == 0)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyActionInfo <>).MakeGenericType(type), methodInfo);
}
else if (parameters.Length == 1)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyActionInfo <,>).MakeGenericType(type, parameters[0].ParameterType), methodInfo);
}
else if (parameters.Length == 2)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyActionInfo <, ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType), methodInfo);
}
else if (parameters.Length == 3)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyActionInfo <, , ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType, parameters[2].ParameterType), methodInfo);
}
else
{
info = new ProxyMethodInfo(methodInfo);
}
}
else
{
if (parameters == null || parameters.Length == 0)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyActionInfo <>).MakeGenericType(type), methodInfo);
}
else if (parameters.Length == 1)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyActionInfo <,>).MakeGenericType(type, parameters[0].ParameterType), methodInfo);
}
else if (parameters.Length == 2)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyActionInfo <, ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType), methodInfo);
}
else if (parameters.Length == 3)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyActionInfo <, , ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType, parameters[2].ParameterType), methodInfo);
}
else
{
info = new ProxyMethodInfo(methodInfo);
}
}
}
else
{
if (methodInfo.IsStatic)
{
if (parameters == null || parameters.Length == 0)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyFuncInfo <,>).MakeGenericType(type, returnType), methodInfo);
}
else if (parameters.Length == 1)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyFuncInfo <, ,>).MakeGenericType(type, parameters[0].ParameterType, returnType), methodInfo);
}
else if (parameters.Length == 2)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyFuncInfo <, , ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType, returnType), methodInfo);
}
else if (parameters.Length == 3)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(StaticProxyFuncInfo <, , , ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType, parameters[2].ParameterType, returnType), methodInfo);
}
else
{
info = new ProxyMethodInfo(methodInfo);
}
}
else
{
if (parameters == null || parameters.Length == 0)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyFuncInfo <,>).MakeGenericType(type, returnType), methodInfo);
}
else if (parameters.Length == 1)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyFuncInfo <, ,>).MakeGenericType(type, parameters[0].ParameterType, returnType), methodInfo);
}
else if (parameters.Length == 2)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyFuncInfo <, , ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType, returnType), methodInfo);
}
else if (parameters.Length == 3)
{
info = (IProxyMethodInfo)Activator.CreateInstance(typeof(ProxyFuncInfo <, , , ,>).MakeGenericType(type, parameters[0].ParameterType, parameters[1].ParameterType, parameters[2].ParameterType, returnType), methodInfo);
}
else
{
info = new ProxyMethodInfo(methodInfo);
}
}
}
}
catch (Exception)
{
info = new ProxyMethodInfo(methodInfo);
}
#endif
if (info != null)
{
this.AddMethodInfo(info);
}
return(info);
}
public MethodNodeProxy(object source, IProxyMethodInfo methodInfo) : base(source)
{
this.methodInfo = methodInfo;
this.invoker = new ProxyInvoker(this.source, this.methodInfo);
}
public MethodNodeProxy(IProxyMethodInfo methodInfo) : this(null, methodInfo)
{
}
