protected static async Task <IResponse <TResult> > Try(IResponse <TResult> response, Func <TResult, Task <IResponse> > request, IResponseComposer responseComposer, IObjectLogger logger)
{
var result = await request(response.Payload);
HandleResponse(logger, result);
return(result.Succeeded
? response
: responseComposer.From <TResult>(result));
}
private static IResponse <TCombineResult> GetCombineResult <TCombineResult>(
Func <TFrom, TRequestResult, TCombineResult> combine, IResponse <TFrom> first,
IResponse <TRequestResult> second, IResponseComposer composer)
{
if (!first.Succeeded)
{
return(composer.From <TCombineResult>(second));
}
if (!second.Succeeded)
{
return(composer.From <TCombineResult>(second));
}
try
{
return(composer.Success(combine(first.Payload, second.Payload)));
}
catch (Exception ex)
{
return(composer.Error <TCombineResult>(ex));
}
}
public override async Task <IResponse <TResult> > GetResult(IObjectLogger logger, IResponseComposer responseComposer)
{
Debug.Assert(this.Parent != null);
Debug.Assert(this.Request != null);
try
{
var parentResult = await this.Parent.GetResult(logger, responseComposer);
if (!parentResult.Succeeded)
{
return(responseComposer.From <TFrom, TResult>(parentResult));
}
var response = this.ProcessResponse(logger, await this.GetResponse(parentResult, logger, responseComposer));
return(await this.TransformFunc(parentResult, response, responseComposer, logger));
}
catch (Exception e)
{
logger.LogCritical(e);
return(responseComposer.Error <TResult>(e));
}
}
