private async Task <object> UnwrapTaskResultAsync(FieldContext fieldContext, FieldResolverInfo fieldResolver, Task task)
{
if (!task.IsCompleted)
{
await task;
}
switch (task.Status)
{
case TaskStatus.Faulted:
Exception origExc = task.Exception;
if (origExc is AggregateException aex)
{
origExc = aex.InnerException; //we expect just one exc (we ignore exc.InnerExceptions list)
}
AddError(fieldContext, origExc, ErrorCodes.ResolverError);
Fail();
return(null);
case TaskStatus.RanToCompletion:
var resReader = fieldResolver.ResolverMethod.TaskResultReader;
var result = resReader(task);
return(result);
case TaskStatus.Canceled:
default:
var msg = "Resolver execution canceled.";
fieldContext.AddError(msg, ErrorCodes.Cancelled);
throw new ResolverException(msg);
}
}
private void InitFieldResolvers()
{
var objTypes = _model.Types.Where(tdef => tdef.Kind == TypeKind.Object).OfType <ObjectTypeDef>();
foreach (var typeDef in objTypes)
{
foreach (var mapping in typeDef.Mappings)
{
foreach (var fldDef in typeDef.Fields)
{
var fres = new FieldResolverInfo()
{
Field = fldDef, TypeMapping = mapping
};
mapping.FieldResolvers.Add(fres);
}
}
}
}
// gets cached resolver class instance or creates new one
private void AssignResolverClassInstance(FieldContext fieldCtx, FieldResolverInfo fieldResolver)
{
var resClassType = fieldResolver.ResolverMethod.ResolverClass.Type;
object resInstance = null;
if (_resolverInstances.Count == 1 && _resolverInstances[0].GetType() == resClassType) // fast track
{
resInstance = _resolverInstances[0];
}
else
{
resInstance = _resolverInstances.FirstOrDefault(r => r.GetType() == resClassType);
}
if (resInstance == null)
{
resInstance = Activator.CreateInstance(resClassType);
if (resInstance is IResolverClass iRes)
{
iRes.BeginRequest(_requestContext);
}
_resolverInstances.Add(resInstance);
}
fieldCtx.ResolverClassInstance = resInstance;
}
public MappedSelectionField(SelectionField field, FieldResolverInfo resolver) : base(field)
{
Field = field;
Resolver = resolver;
}
