Erfassen von HTML, das von ASP.NET generiert wurde

Question

Wie zeichne ich den HTML-Code (in meiner Instanz für die Protokollierung) am besten auf einer aspx-Seite auf?

Ich möchte nicht mit Response.Write auf die Seite zurückschreiben, da es mein Website-Layout vermasselt.

Mit dem Response.OutputStream oder Response.Output Stream führt zu einer Argument ({System.ArgumentException:. Strom war nicht lesbar)

Answer 1

Gute Frage, ich musste ausprobieren und sehen, ob ich ein HttpModule erstellen könnte, um zu tun, was Sie beschreiben.

Ich hatte kein Glück zu versuchen, aus dem Responsestream zu lesen, aber die Verwendung des ResponseFilter gab mir eine Möglichkeit, den Inhalt zu erfassen.

Der folgende Code scheint ziemlich gut zu funktionieren, und ich dachte, vielleicht könnten Sie den Code als Basis verwenden. Aber denken Sie daran, dass dies nur etwas ist, was ich schnell zusammengestellt habe, es wurde in keiner Weise getestet. Verwenden Sie es daher nicht in einer Produktionsumgebung ohne entsprechende Überprüfung/Tests und dergleichen. Fühlen Sie sich frei, es zu kommentieren;)

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

Viele Last-Tester können Sie die HTTP-Antworten generiert, protokollieren, aber tragen in Bei ASP.NET könnten das einige sehr große Protokolldateien sein.

Edit: Response.Filter nach Tom Jelen Code ist so konzipiert, dass diese Art von Aufsicht geben und Response.Outputstream ist sonst nicht lesbar.

Edit 2: Für eine Seite eher als ein 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() */ 

    //... 

} 

und in Ihrem Page_Load (oder vor Ihrer Antwort sowieso geschrieben wird)

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

Answer 3

Eine Möglichkeit, serverseitige XMLHTTP zu machen Anfrage an Ihren eigenen Server. Ergreifen Sie das Ergebnis und speichern Sie es in einer Datei oder DB.

Alternativ können Sie AJAX auf dem Client verwenden, nehmen Sie das Ergebnis und POST es zurück auf den Server.