private void ResolveArgument(GraphArgumentInfo argument, IResolutionContext resolutionContext)
{
if (argument.IsInjected)
{
object obj;
var argumentType = (TypeInfo)argument.Type.AttributeProvider;
if (argumentType.AsType() == typeof(IResolutionContext) ||
argumentType.ImplementedInterfaces.Any(iface => iface == typeof(IResolutionContext)))
{
obj = resolutionContext;
}
else if (argumentType.AsType() == typeof(IUserContext) ||
argumentType.ImplementedInterfaces.Any(iface => iface == typeof(IUserContext)))
{
obj = resolutionContext.UserContext;
}
else if (argumentType.AsType() == typeof(CancellationToken))
{
obj = resolutionContext.CancellationToken;
}
else
{
obj = resolutionContext.DependencyInjector?.Resolve(argumentType);
}
resolutionContext.SetArgument(argument.Name, obj);
}
else
{
var argumentValue = resolutionContext.GetArgument(argument);
resolutionContext.SetArgument(argument.Name, Wrapper.Wrap(argument, argument.Type, argumentValue, true));
}
}
private object CallMethod(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var methodInfo = fieldInfo.AttributeProvider as MethodInfo;
var arguments = fieldInfo
.Arguments
.Select(arg => context.GetArgument(arg.Name, arg.DefaultValue));
return(methodInfo?.Invoke(source, arguments.ToArray()));
}
public override async Task <object> Execute(IResolutionContext context, FieldResolutionDelegate next)
{
var output = await next(context).ConfigureAwait(false);
var input = Unwrap(context.GetArgument("input"));
if (input is IRelayMutationInputObject inputObj && output is IRelayMutationOutputObject outputObj)
{
outputObj.ClientMutationId = inputObj.ClientMutationId;
}
return(output);
}
private object CallMethod(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var methodInfo = fieldInfo.AttributeProvider as MethodInfo;
var arguments = fieldInfo
.Arguments
.Select(arg => context.GetArgument(arg));
if (fieldInfo.IsExtensionMethod)
{
arguments = new[] { source }.Concat(arguments);
}
return(methodInfo?.Invoke(source, arguments.ToArray()));
}
private object CallMethod(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var methodInfo = fieldInfo.AttributeProvider as MethodInfo;
var arguments = fieldInfo
.Arguments
.Select(arg => context.GetArgument(arg));
if (fieldInfo.Type.IsTask)
{
var argumentTypes = methodInfo.GetParameters().Select(p => p.ParameterType).ToList();
var argumentConstants = arguments.Select((arg, i) => Expression.Constant(arg, argumentTypes[i]));
var methodCall = Expression.Call(Expression.Constant(source), methodInfo, argumentConstants);
var resolutionTask = Expression.Lambda(methodCall).Compile();
return(Task.Run(() => AsyncHelpers.RunTask(resolutionTask, fieldInfo.Type.TypeParameter())));
}
return(methodInfo?.Invoke(source, arguments.ToArray()));
}
