È necessario accedere al corpo della richiesta e della risposta di asp.net webapi 2 in un database

Sto utilizzando Microsoft Asp.net WebApi2 ospitato su IIS. Vorrei semplicemente registrare il corpo della richiesta (XML o JSON) e il corpo della risposta per ogni post.

Non c'è niente di speciale in questo progetto o nel controllore che elabora il post. Non mi interessa usare framework di registrazione come nLog, elmah, log4net o le funzionalità di tracciamento integrate dell'API web a meno che non sia necessario farlo.

Vorrei semplicemente sapere dove inserire il mio codice di registrazione e come ottenere il JSON o XML effettivo dalla richiesta e risposta in entrata e in uscita.

Il mio metodo di post del controller:

public HttpResponseMessage Post([FromBody])Employee employee)
{
   if (ModelState.IsValid)
   {
      // insert employee into to the database
   }

}

Consiglierei di usare un file DelegatingHandler. Quindi non dovrai preoccuparti di alcun codice di registrazione nei tuoi controller.

public class LogRequestAndResponseHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        if (request.Content != null)
        {
            // log request body
            string requestBody = await request.Content.ReadAsStringAsync();
            Trace.WriteLine(requestBody);
        }
        // let other handlers process the request
        var result = await base.SendAsync(request, cancellationToken);

        if (result.Content != null)
        {
            // once response body is ready, log it
            var responseBody = await result.Content.ReadAsStringAsync();
            Trace.WriteLine(responseBody);
        }

        return result;
    }
}

Basta sostituire Trace.WriteLinecon il codice di registrazione e registrare il gestore in WebApiConfigquesto modo:

config.MessageHandlers.Add(new LogRequestAndResponseHandler());

Ecco la documentazione Microsoft completa per i gestori di messaggi .

Esistono più approcci per gestire genericamente la registrazione di richieste / risposte per ogni chiamata al metodo WebAPI:

1. ActionFilterAttribute: Si può scrivere personalizzato ActionFilterAttributee decorare i metodi di controller / azione per abilitare la registrazione.

   Contro: è necessario decorare ogni controller / metodo (è comunque possibile farlo sul controller di base, ma non risolve i problemi di taglio incrociato.

2. Esegui l'override BaseControllere gestisci la registrazione lì.

   Contro: Ci aspettiamo / costringiamo i controller a ereditare da un controller di base personalizzato.

3. Utilizzando DelegatingHandler.

   Vantaggio: non stiamo toccando controller / metodo qui con questo approccio. Il gestore di delega si trova in isolamento e gestisce con grazia la registrazione di richieste / risposte.

Per un articolo più approfondito, fare riferimento a questo http://weblogs.asp.net/fredriknormen/log-message-request-and-response-in-asp-net-webapi .

Una delle opzioni che hai è usare la creazione di un filtro di azione e decorare il tuo WebApiController / ApiMethod con esso.

Attributo di filtro

public class MyFilterAttribute : System.Web.Http.Filters.ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            if (actionContext.Request.Method == HttpMethod.Post)
            {
                var postData = actionContext.ActionArguments;
                //do logging here
            }
        }
    }

Controller WebApi

[MyFilterAttribute]
public class ValuesController : ApiController{..}

o

[MyFilterAttribute]
public void Post([FromBody]string value){..}

Spero che questo ti aiuti.

Ottenere l'accesso al messaggio di richiesta è facile. La tua classe base,ApiController contiene una .Requestproprietà che, come suggerisce il nome, contiene la richiesta in forma analizzata. Basta esaminarlo per qualsiasi cosa tu stia cercando di registrare e passarlo alla tua struttura di registrazione, qualunque essa sia. Questo codice puoi inserire all'inizio della tua azione, se devi farlo solo per uno o per una manciata.

Se hai bisogno di farlo su tutte le azioni (tutto significa più di una manciata gestibile), allora quello che puoi fare è sovrascrivere il .ExecuteAsyncmetodo per catturare ogni chiamata di azione per il tuo controller.

public override Task<HttpResponseMessage> ExecuteAsync(
    HttpControllerContext controllerContext,
    CancellationToken cancellationToken
)
{
    // Do logging here using controllerContext.Request
    return base.ExecuteAsync(controllerContext, cancellationToken);
}

Questo sembra essere un thread piuttosto vecchio, ma sto condividendo un'altra soluzione.

Puoi aggiungere questo metodo nel tuo file global.asax che verrà attivato ogni volta che termina la richiesta HTTP.

void Application_EndRequest(Object Sender, EventArgs e)
    {
        var request = (Sender as HttpApplication).Request;
        var response = (Sender as HttpApplication).Response;

        if (request.HttpMethod == "POST" || request.HttpMethod == "PUT")
        {


            byte[] bytes = request.BinaryRead(request.TotalBytes);
            string body = Encoding.UTF7.GetString(bytes);
            if (!String.IsNullOrEmpty(body))
            {


                // Do your logic here (Save in DB, Log in IIS etc.)
            }
        }
    }

Questo è un argomento davvero vecchio ma ho passato molto tempo (ricerca in Internet) per fare queste cose, quindi pubblicherò qui la mia soluzione.

Concetto

1. Override ExecuteAsync del metodo APicontroller per il monitoraggio della richiesta in entrata, nella mia soluzione creo Base_ApiController come genitore dei controller API del mio progetto.
2. Usa System.Web.Http.Filters.ActionFilterAttribute per tenere traccia della risposta in uscita del controller api
3. *** (aggiuntivo) *** Utilizzare System.Web.Http.Filters.ExceptionFilterAttribute per registrare quando si verifica un'eccezione.

1. MyController.cs

    [APIExceptionFilter]  // use 3.
    [APIActionFilter]     // use 2.
    public class Base_APIController : ApiController
    {
        public   bool  IsLogInbound
        {
            get
            { return   ConfigurationManager.AppSettings["LogInboundRequest"] =="Y"? true:false ;     }
        }
        /// <summary>
        /// for logging exception
        /// </summary>
        /// <param name="controllerContext"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public override Task<HttpResponseMessage> ExecuteAsync(
         HttpControllerContext controllerContext,
         CancellationToken cancellationToken
         )
        {
            // Do logging here using controllerContext.Request
            // I don't know why calling the code below make content not null Kanit P.
            var content = controllerContext.Request.Content.ReadAsStringAsync().Result.ToString(); // keep request json content
             // Do your own logging!
            if (IsLogInbound)
            {
                try
                {
                    ErrLog.Insert(ErrLog.type.InboundRequest, controllerContext.Request,
                         controllerContext.Request.RequestUri.AbsoluteUri
                         , content);
                }
                catch (Exception e) { }
            }

            // will not log err when go to wrong controller's action (error here but not go to APIExceptionFilter)
            var t = base.ExecuteAsync(controllerContext, cancellationToken);
            if (!t.Result.IsSuccessStatusCode)
            { 
            }
            return t;

        }

2. APIActionFilter.cs

    public class APIActionFilter : System.Web.Http.Filters.ActionFilterAttribute
    {
        public bool LogOutboundRequest
        {
            get
            { return ConfigurationManager.AppSettings["LogInboundRequest"] == "Y" ? true : false; }
        }

        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            try {

                var returndata = actionExecutedContext.Response.Content.ReadAsStringAsync().Result.ToString(); 
             //keep Json response content
             // Do your own logging!
                if (LogOutboundRequest)
                {
                    ErrLog.Insert(ErrLog.type.OutboundResponse, actionExecutedContext.Response.Headers,
                       actionExecutedContext.ActionContext.ControllerContext.ControllerDescriptor.ControllerName
                      + "/"
                      + actionExecutedContext.ActionContext.ActionDescriptor.ActionName
                      , returndata );
                }
            } catch (Exception e) {

            }
     

        } 
    }
}

3. APIExceptionFilter.cs

    public class APIExceptionFilter : ExceptionFilterAttribute
    {
    public bool IsLogErr
    {
        get
        { return ConfigurationManager.AppSettings["LogExceptionRequest"] == "Y" ? true : false; }
    }


    public override void OnException(HttpActionExecutedContext context)
    {
        try
        { 
            //Do your own logging!
            if (IsLogErr)
            {
                ErrLog.Insert(ErrLog.type.APIFilterException, context.Request,
                    context.ActionContext.ControllerContext.ControllerDescriptor.ControllerName
                    + "/"
                    + context.ActionContext.ActionDescriptor.ActionName
                    , context.Exception.ToString() + context.Exception.StackTrace);
            }
        }catch(Exception e){

        }

        if (context.Exception is NotImplementedException)
        {
            context.Response = new HttpResponseMessage(HttpStatusCode.NotImplemented);
        }
        else {
            context.Response = new HttpResponseMessage(HttpStatusCode.InternalServerError);

        }
    }
}