CodeS-SourceS
Rechercher un code, un tuto, une réponse

Response.filter : manipulation du stream de sortie asp.net

Soyez le premier à donner votre avis sur cette source.

Snippet vu 11 532 fois - Téléchargée 7 fois

Contenu du snippet

Dans certains cas, on a besoin de pouvoir manipuler le Stream dans lequel écrit ASP.net. Par exemple, on aimerait récupérer le flux de sortie afin d'enregistrer dans un fichier toutes les pages générées par ASP.net
Pour cela l'objet HttpResponse expose une propriété Filter. Cette propriété de type Stream est en lecture/écriture.

Cette source montre comment écraser la propriété Response.Filter afin d'enregistrer le flux envoyé au client sur le disque.
Pour cela nous utilisons un HttpModule.

Source / Exemple :


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.IO;
using System.Web.UI;

public class FilterSampleModule : IHttpModule
{

    public void Dispose() { }

    public void Init(HttpApplication context)
    {
        context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute);
    }

    void context_PreRequestHandlerExecute(object sender, EventArgs e)
    {
        if (!(HttpContext.Current.Handler is Page))
            return;

        HttpContext.Current.Response.Filter = new MyStream(HttpContext.Current.Response.Filter);
    }

}

public class MyStream : Stream
{

    private Stream _originalStream;
    private Stream _newStream;

    public MyStream(Stream originalStream)
    {
        this._originalStream = originalStream;
        this._newStream = new FileStream(@"c:/toto.html", FileMode.Create);
    }

    public override bool CanRead
    {
        get { return this._originalStream.CanRead; }
    }

    public override bool CanSeek
    {
        get { return this._originalStream.CanSeek; }
    }

    public override bool CanWrite
    {
        get { return this._originalStream.CanWrite; }
    }

    public override void Flush()
    {
        this._newStream.Flush();
        this._originalStream.Flush();
    }

    public override long Length
    {
        get { return this._originalStream.Length; }
    }

    public override long Position
    {
        get
        {
            return this._originalStream.Position;
        }
        set
        {
            this._originalStream.Position = value;
            this._newStream.Position = value;
        }
    }

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

    public override long Seek(long offset, SeekOrigin origin)
    {
        this._newStream.Seek(offset, origin);
        return this._originalStream.Seek(offset, origin);
    }

    public override void SetLength(long value)
    {
        this._originalStream.SetLength(value);
        this._newStream.SetLength(value);
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        this._originalStream.Write(buffer, offset, count);
        this._newStream.Write(buffer, offset, count);
    }

    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);
        if (disposing)
            this._newStream.Dispose();
    }

}

Conclusion :


D'autres informations sont également disponible ici :

Cette source est juste un exemple d'utilisation de la propriété HttpResponse.Filter (http://msdn.microsoft.com/en-us/library/system.web.httpresponse.filter.aspx)

Afin que cela fonctionne, n'oublier pas d'inscrire le HttpModule dans le web.config.

<configuration>
<system.web>
<httpModules>
<add name="FilterSampleModule" type="FilterSampleModule, App_Code"/>
</httpModules>
</system.web>
</configuration>

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.