Capture de code HTML généré à partir d'ASP.NET

Question

Comment puis-je capturer au mieux le code HTML (dans mon cas, pour la journalisation) rendu par une page aspx?

Je ne veux pas avoir à écrire à la page en utilisant Response.Write, car cela perturbe la mise en page de mon site.

Utilisation du Response.OutputStream ou les résultats de flux de Response.Output dans un ArgumentException ({System.ArgumentException:. Végétalisées était illisible)

Answer 1

Bonne question, j'ai dû essayer et voir si je pouvais créer un HttpModule pour faire ce que vous décrivez.

Je n'ai pas eu de chance d'essayer de lire depuis le flux de réponses, mais en utilisant le ResponseFilter m'a donné un moyen de capturer le contenu.

Le code suivant semble très bien fonctionner, et j'ai pensé que vous pourriez peut-être utiliser le code comme base. Mais rappelez-vous ceci est juste quelque chose que j'ai jeté ensemble rapidement, il n'a pas été testé en aucune façon. Donc, ne l'utilisez pas dans n'importe quel environnement de production sans révision/test approprié et autres. N'hésitez pas à commenter;)

public class ResponseLoggerModule : IHttpModule 
{ 
    private class ResponseCaptureStream : Stream 
    { 
     private readonly Stream _streamToCapture; 
     private readonly Encoding _responseEncoding; 

     private string _streamContent; 
     public string StreamContent 
     { 
      get { return _streamContent; } 
      private set 
      { 
       _streamContent = value; 
      } 
     } 

     public ResponseCaptureStream(Stream streamToCapture, Encoding responseEncoding) 
     { 
      _responseEncoding = responseEncoding; 
      _streamToCapture = streamToCapture; 

     } 

     public override bool CanRead 
     { 
      get { return _streamToCapture.CanRead; } 
     } 

     public override bool CanSeek 
     { 
      get { return _streamToCapture.CanSeek; } 
     } 

     public override bool CanWrite 
     { 
      get { return _streamToCapture.CanWrite; } 
     } 

     public override void Flush() 
     { 
      _streamToCapture.Flush(); 
     } 

     public override long Length 
     { 
      get { return _streamToCapture.Length; } 
     } 

     public override long Position 
     { 
      get 
      { 
       return _streamToCapture.Position; 
      } 
      set 
      { 
       _streamToCapture.Position = value; 
      } 
     } 

     public override int Read(byte[] buffer, int offset, int count) 
     { 
      return _streamToCapture.Read(buffer, offset, count); 
     } 

     public override long Seek(long offset, SeekOrigin origin) 
     { 
      return _streamToCapture.Seek(offset, origin); 
     } 

     public override void SetLength(long value) 
     { 
      _streamToCapture.SetLength(value); 
     } 

     public override void Write(byte[] buffer, int offset, int count) 
     { 
      _streamContent += _responseEncoding.GetString(buffer); 
      _streamToCapture.Write(buffer, offset, count); 
     } 

     public override void Close() 
     { 
      _streamToCapture.Close(); 
      base.Close(); 
     } 
    } 

    #region IHttpModule Members 

    private HttpApplication _context; 
    public void Dispose() 
    { 

    } 

    public void Init(HttpApplication context) 
    { 
     _context = context; 

     context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute); 
     context.PreSendRequestContent += new EventHandler(context_PreSendRequestContent); 
    } 

    void context_PreRequestHandlerExecute(object sender, EventArgs e) 
    { 
     _context.Response.Filter = new ResponseCaptureStream(_context.Response.Filter, _context.Response.ContentEncoding); 
    } 

    void context_PreSendRequestContent(object sender, EventArgs e) 
    { 
     ResponseCaptureStream filter = _context.Response.Filter as ResponseCaptureStream; 

     if (filter != null) 
     { 
      string responseText = filter.StreamContent; 

      // Logging logic here 
     } 
    } 

    #endregion 
} 

Answer 2

De nombreux testeurs de charge vous permettra de vous connecter les réponses HTTP générées, mais gardez à esprit avec ASP.NET ceux-ci pourraient être de très gros fichiers journaux.

Éditer: Response.Filter selon le code de Tom Jelen est conçu pour donner ce genre de surveillance et Response.Outputstream est autrement illisible.

Edit 2: Pour une page plutôt qu'un HttpModule

public class ObserverStream : Stream 
{ 
    private byte[] buffer = null; 
    private Stream observed = null; 

    public ObserverStream (Stream s) 
    { 
    this.observed = s; 
    } 

    /* important method to extend #1 : capturing the data */ 
    public override void Write(byte[] buffer, int offset, int count) 
    { 
    this.observed.Write(buffer, offset, count); 
    this.buffer = buffer; //captured! 
    } 

    /* important method to extend #2 : doing something with the data */ 
    public override void Close() 
    { 
    //this.buffer available for logging here! 
    this.observed.Close(); 
    } 

    /* override all the other Stream methods/props with this.observed.method() */ 

    //... 

} 

et dans votre Page_Load (ou avant votre réponse écrite de toute façon)

Response.Filter = new ObserverStream(Response.Filter); 

Answer 3

Une façon de faire XMLHTTP côté serveur demande à votre propre serveur. Saisissez le résultat et enregistrez-le dans un fichier ou une base de données.

Vous pouvez également utiliser AJAX sur le client, récupérer le résultat et le POSTER sur le serveur.