public ReactMethodInfo(ReflectionMethodInfo methodInfo, ReactMethodAttribute methodAttribute)
{
MethodName = methodAttribute.MethodName ?? methodInfo.Name;
Type returnType = methodInfo.ReturnType;
ParameterInfo[] parameters = methodInfo.GetParameters();
if (returnType != typeof(void))
{
MethodReturnType = MethodReturnType.Callback;
MethodImpl = new Lazy <ReactMethodImpl>(() => MakeReturningMethod(methodInfo, returnType, parameters), LazyThreadSafetyMode.PublicationOnly);
}
else
{
if (parameters.Length > 0 && typeof(Delegate).IsAssignableFrom(parameters[parameters.Length - 1].ParameterType))
{
if (parameters.Length > 1 && typeof(Delegate).IsAssignableFrom(parameters[parameters.Length - 2].ParameterType))
{
MethodReturnType = MethodReturnType.Promise;
MethodImpl = new Lazy <ReactMethodImpl>(() => MakePromiseMethod(methodInfo, parameters), LazyThreadSafetyMode.PublicationOnly);
}
else
{
MethodReturnType = MethodReturnType.Callback;
MethodImpl = new Lazy <ReactMethodImpl>(() => MakeCallbackMethod(methodInfo, parameters), LazyThreadSafetyMode.PublicationOnly);
}
}
else
{
MethodReturnType = MethodReturnType.Void;
MethodImpl = new Lazy <ReactMethodImpl>(() => MakeFireAndForgetMethod(methodInfo, parameters), LazyThreadSafetyMode.PublicationOnly);
}
}
}
public ReactMethodInfo(MethodInfo methodInfo, ReactMethodAttribute methodAttribute)
{
MethodName = methodAttribute.MethodName ?? methodInfo.Name;
Type returnType = methodInfo.ReturnType;
ParameterInfo[] parameters = methodInfo.GetParameters();
Type lastParameterType = parameters.Length > 0 ? parameters[parameters.Length - 1].ParameterType : null;
Type secondToLastParameterType = parameters.Length > 1 ? parameters[parameters.Length - 2].ParameterType : null;
Func <ReactMethodImpl> createMethod;
bool isPromise(Type type)
{
var typeInfo = type?.GetTypeInfo();
if (typeInfo != null && typeInfo.IsGenericType)
{
var genericArgs = type.GetGenericArguments();
if (genericArgs.Length == 1)
{
return(typeof(IReactPromise <>).MakeGenericType(genericArgs).IsAssignableFrom(type));
}
}
return(false);
}
bool isCallback(Type type) => type != null && typeof(Delegate).IsAssignableFrom(type);
if (returnType != typeof(void))
{
MethodReturnType = MethodReturnType.Callback;
createMethod = () => MakeReturningMethod(methodInfo, returnType, parameters);
}
else if (isPromise(lastParameterType))
{
MethodReturnType = MethodReturnType.Promise;
createMethod = () => MakePromiseMethod(methodInfo, parameters);
}
else if (isCallback(lastParameterType))
{
if (isCallback(secondToLastParameterType))
{
MethodReturnType = MethodReturnType.TwoCallbacks;
createMethod = () => MakeTwoCallbacksMethod(methodInfo, parameters);
}
else
{
MethodReturnType = MethodReturnType.Callback;
createMethod = () => MakeCallbackMethod(methodInfo, parameters);
}
}
else
{
MethodReturnType = MethodReturnType.Void;
createMethod = () => MakeFireAndForgetMethod(methodInfo, parameters);
}
MethodImpl = new Lazy <ReactMethodImpl>(createMethod, LazyThreadSafetyMode.PublicationOnly);
}
