WebAPI HttpContent转换为类型化对象

Question

I am working on custom filter which should accomplish simple thing. All my APIs wrapped into 'Response' object. I want to fill in all properties using filter. This is code I have for the filter:

public class MeteringFilter : IActionFilter
    {
        public Task<HttpResponseMessage> ExecuteActionFilterAsync(
            HttpActionContext actionContext,
            CancellationToken cancellationToken,
            Func<Task<HttpResponseMessage>> continuation)
        {
            var attribute =
                actionContext.ActionDescriptor.GetCustomAttributes<MeterAttribute>(true).SingleOrDefault() ??
                actionContext.ActionDescriptor.ControllerDescriptor.GetCustomAttributes<MeterAttribute>(true).SingleOrDefault();

            if (attribute == null) return continuation();

            var operation = actionContext.ActionDescriptor.ActionName;
            var user = actionContext.RequestContext.Principal.Identity.Name;
            var started = DateTimeOffset.Now;
            return continuation().ContinueWith(t => 
            {
                var completed = DateTimeOffset.Now;
                var duration = completed - started;

                var c = t.Result.Content;
                // This is code which does not work but I like to have:
                // When debugger stops here I can see Content.Value and my object but I can't use this property like below
                var cv = t.Result.Content.Value as Response<object>;

                return t.Result;
            });
        }

        public bool AllowMultiple => true;
    }

I found similar question where it was suggested to do var c = t.Result.Content.ReadAsAsync(typeof(Response<>)); but I can't do this because I can't make lambda function async in this case.

Any suggestion on how to get typed object out of HttpContent so I can assign properties before it returns to caller?

Here is Response<T>

public class Response<T>
    {
        public string Url { get; set; }

        public DateTime ServerTime { get; set; }

        public TimeSpan TimeTook { get; set; }

        public T Data { get; set; }

        public Error Error { get; set; }
    }

EDIT

Here is how code looks now. I do get access to object, but webservice does not respond with data I fill to client. It seems that code executed later after serialization/media formatting takes place.

I guess question becomes how do I add generic "handler" before web service returns but with access to beginning of call (so I can measure times, see request params, etc)

return continuation().ContinueWith(t => 
            {
                var c = t.Result.Content.ReadAsAsync(typeof(Response<object>), cancellationToken);
                if (c.Result is Response<object> response)
                {
                    Debug.WriteLine("Adding times");
                    response.ServerTime = startedOn;
                    response.TimeTook = DateTime.Now - startedOn;
                }

                return t.Result;
            }, cancellationToken);

EDIT 2:

Here is sample web api method which I want to intercept:

[HttpGet]
        public Response<LookupResponseData> Carrier(int? key = null, string id = "")
        {
            return this.GetKeyIdBundleForLookup("Carriers", key, id);
        }


private Response<LookupResponseData> GetKeyIdBundleForLookup(string lookupId, int? key, string id)
        {
            if (!key.HasValue && string.IsNullOrEmpty(id))
                return new Response<LookupResponseData>
                {
                    Error = new Error { Code = ErrorCodes.InvalidQueryParameter, Message = "Either key or id must be specified" }
                };

            var r = new Response<LookupResponseData>();
            try
            {
                this.LookupService.GetKeyIdDescription(this.AccountId, lookupId, key, id, out var keyResult, out var idResult, out var description);
                if (!keyResult.HasValue)
                    return new Response<LookupResponseData>
                    {
                        Error = new Error { Code = ErrorCodes.InvalidOrMissingRecord, Message = "No record found for parameters specified" }
                    };

                r.Data = new LookupResponseData { Key = keyResult.Value, Id = idResult, Description = description };
            }
            catch (Exception ex)
            {
                this.LoggerService.Log(this.AccountId, ex);
                return new Response<LookupResponseData>
                {
                    Error = new Error { Code = ErrorCodes.Unknown, Message = "API Call failed, please contact support. Details logged." }
                };
            }

            return r;
        }

Answer 1

All my APIs wrapped into 'Response' object.

First you can simplify your results by creating a implicit operators:

public class Response
{
    public string Url { get; set; }
    public DateTime ServerTime { get; set; }
    public TimeSpan TimeTook { get; set; }
}

public class Response<T> : Response
{
    public T Data { get; set; }
    public Error Error { get; set; }

    public static implicit operator Response<TData>(TData data)
    {
        var result = new Response<TData>
        {
          Data = data,
        };

        return result;
    }

    public static implicit operator Response<TData>(Error error)
    {
        var result = new Response<TData>
        {
          Error = error,
        };

        return result;
    }
}

Now it should be easier to really ignore the repeated code of creating the response:

private Response<LookupResponseData> GetKeyIdBundleForLookup(
  string lookupId, int? key, string id)
{
  if (!key.HasValue && string.IsNullOrEmpty(id))
    return new Error 
    { 
      Code = ErrorCodes.InvalidQueryParameter, 
      Message = "Either key or id must be specified" 
    };

  try
  {
    this.LookupService.GetKeyIdDescription(this.AccountId, 
      lookupId, 
      key, 
      id, 
      out var keyResult, 
      out var idResult, 
      out var description);
    if (!keyResult.HasValue)
      return new Error 
      {
        Code = ErrorCodes.InvalidOrMissingRecord, 
        Message = "No record found for parameters specified" 
      };

    return new LookupResponseData 
    { 
      Key = keyResult.Value, 
      Id = idResult, Description = description 
    };

  catch (Exception ex)
  {
    this.LoggerService.Log(this.AccountId, ex);
    return new Error 
    { 
      Code = ErrorCodes.Unknown, 
      Message = "API Call failed, please contact support. Details logged." }
    };
  }
}

Then you can create an Core Async Action Filter :

public class SampleAsyncActionFilter : IAsyncActionFilter
{
  public async Task OnActionExecutionAsync(
    ActionExecutingContext context,
    ActionExecutionDelegate next)
  {
    // do something before the action executes
    var started = DateTimeOffset.Now;     

    // Action Executes
    var resultContext = await next();

    // do something after the action executes; resultContext.Result will be set
    if  (result.Context.Result is Response response)
    {
      response.ServerTime = started;
      response.TimeTook = DateTimeOffset.Now - started;
    }
  }
}

Or Non-Core (MVC):

public class SampleActionFilter : ActionFilterAttribute
{
  private const string TimerKey = nameof(SampleActionFilter ) + "_TimerKey";

  public override void OnActionExecuting(ActionExecutingContext context)
  {
    context.HttpContext.Items[TimerKey] = DateTimeOffset.Now;
  }

  public override void OnActionExecuted(ActionExecutedContext context)
  {
    if (context.Result is Response response)
      && context.HttpContext.Items[TimerKey] is DateTimeOffset started) 
    {
      response.ServerTime = started;
      response.TimeTook = DateTimeOffset.Now - started;
    }
  }

Or Non-Core (WebApi):

public class SampleActionFilter : ActionFilterAttribute
{
  private const string TimerKey = nameof(SampleActionFilter ) + "_TimerKey";

  public override void OnActionExecuting(HttpActionContext context)
  {
    context.Request.Properties[TimerKey] = DateTimeOffset.Now;
  }

  public override void OnActionExecuted(HttpActionExecutedContext context)
  {
    if (context.Result is Response response)
      && context.Request.Properties[TimerKey] is DateTimeOffset started) 
    {
      response.ServerTime = started;
      response.TimeTook = DateTimeOffset.Now - started;
    }
  }

Answer 2

I tweaked your code. I hope it helps. I couldn't check syntax errors though

return await continuation().ContinueWith(async t => 
{ 
    var result = await t;
    var c = await result.Content.ReadAsAsync(typeof(Response<object>), cancellationToken);
    if (c is Response<object> response)
    {
        Debug.WriteLine("Adding times");
        response.ServerTime = startedOn;
        response.TimeTook = DateTime.Now - startedOn;
    }

    return result;
}, cancellationToken);