PageStatePersister Classe

Définition

public ref class PageStatePersister abstract

public abstract class PageStatePersister

type PageStatePersister = class

Public MustInherit Class PageStatePersister

Héritage

Object

PageStatePersister

Dérivé

System.Web.UI.HiddenFieldPageStatePersister

System.Web.UI.SessionPageStatePersister

Exemples

L’exemple de code suivant montre comment créer un PageStatePersister objet qui enregistre l’état d’affichage et de contrôle sur le serveur Web. Le montre comment remplacer les Load méthodes et Save pour extraire et enregistrer les StreamPageStatePersister informations d’état d’affichage. Étant donné que les mécanismes de persistance d’état sont liés au rendu adaptatif et aux fonctionnalités clientes, la MyPageAdapter classe est fournie pour activer pour StreamPageStatePersister une application ASP.NET. Enfin, un fichier de fonctionnalités de navigateur (.browser) est fourni pour activer l’adaptateur MyPageAdapter pour une classe spécifique de clients (dans ce cas, le navigateur Web par défaut).

namespace Samples.AspNet.CS
{

    using System;
    using System.IO;
    using System.Security.Permissions;
    using System.Web;
    using System.Web.UI;

    //
    // The StreamPageStatePersister is an example view state
    // persistence mechanism that persists view and control
    // state on the Web server.
    //
    [AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Minimal)]
    public class StreamPageStatePersister : PageStatePersister
    {

        public StreamPageStatePersister(Page page)
            : base(page)
        {
        }
        //
        // Load ViewState and ControlState.
        //
        public override void Load()
        {
            Stream stateStream = GetSecureStream();

            // Read the state string, using the StateFormatter.
            StreamReader reader = new StreamReader(stateStream);

            IStateFormatter formatter = this.StateFormatter;
            string fileContents = reader.ReadToEnd();

            // Deserilize returns the Pair object that is serialized in
            // the Save method.
            Pair statePair = (Pair)formatter.Deserialize(fileContents);

            ViewState = statePair.First;
            ControlState = statePair.Second;
            reader.Close();
            stateStream.Close();
        }
        //
        // Persist any ViewState and ControlState.
        //
        public override void Save()
        {

            if (ViewState != null || ControlState != null)
            {
                if (Page.Session != null)
                {
                    Stream stateStream = GetSecureStream();

                    StreamWriter writer = new StreamWriter(stateStream);

                    IStateFormatter formatter = this.StateFormatter;
                    Pair statePair = new Pair(ViewState, ControlState);

                    // Serialize the statePair object to a string.
                    string serializedState = formatter.Serialize(statePair);

                    writer.Write(serializedState);
                    writer.Close();
                    stateStream.Close();
                }
                else
                {
                    throw new InvalidOperationException("Session needed for StreamPageStatePersister.");
                }
            }
        }
        // Return a secure Stream for your environment.
        private Stream GetSecureStream()
        {
            // You must provide the implementation to build
            // a secure Stream for your environment.
            return null;
        }
    }
}

Imports System.IO
Imports System.Security.Permissions
Imports System.Web
Imports System.Web.UI

Namespace Samples.AspNet.VB

    ' The StreamPageStatePersister is an example view state
    ' persistence mechanism that persists view and control
    ' state on the Web server.
    '
    <AspNetHostingPermission(SecurityAction.Demand, Level:=AspNetHostingPermissionLevel.Minimal)> _
    Public Class StreamPageStatePersister
        Inherits PageStatePersister


        Public Sub New(ByVal page As Page)
            MyBase.New(page)
        End Sub

        '
        ' Load ViewState and ControlState.
        '
        Public Overrides Sub Load()

            Dim stateStream As Stream
            stateStream = GetSecureStream()

            ' Read the state string, using the StateFormatter.
            Dim reader As New StreamReader(stateStream)

            Dim serializedStatePair As String
            serializedStatePair = reader.ReadToEnd
            Dim statePair As Pair

            Dim formatter As IStateFormatter
            formatter = Me.StateFormatter

            ' Deserilize returns the Pair object that is serialized in
            ' the Save method.      
            statePair = CType(formatter.Deserialize(serializedStatePair), Pair)

            ViewState = statePair.First
            ControlState = statePair.Second
            reader.Close()
            stateStream.Close()
        End Sub

        '
        ' Persist any ViewState and ControlState.
        '
        Public Overrides Sub Save()

            If Not (ViewState Is Nothing) OrElse Not (ControlState Is Nothing) Then
                If Not (Page.Session Is Nothing) Then

                    Dim stateStream As Stream
                    stateStream = GetSecureStream()

                    ' Write a state string, using the StateFormatter.
                    Dim writer As New StreamWriter(stateStream)

                    Dim formatter As IStateFormatter
                    formatter = Me.StateFormatter

                    Dim statePair As New Pair(ViewState, ControlState)

                    Dim serializedState As String
                    serializedState = formatter.Serialize(statePair)

                    writer.Write(serializedState)
                    writer.Close()
                    stateStream.Close()
                Else
                    Throw New InvalidOperationException("Session needed for StreamPageStatePersister.")
                End If
            End If
        End Sub
        ' Return a secure Stream for your environment.
        Private Function GetSecureStream() As Stream
            ' You must provide the implementation to build
            ' a secure Stream for your environment.
            Return Nothing
        End Function
    End Class
End Namespace

L’exemple de code suivant montre comment créer une PageAdapter classe qui retourne une instance de StreamPageStatePersister, qui est utilisée pour conserver l’état d’affichage et de contrôle d’une page Web ASP.NET.

namespace Samples.AspNet.CS {

    using System.Security.Permissions;
    using System.Web;
    using System.Web.UI;

    [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class MyPageAdapter : System.Web.UI.Adapters.PageAdapter {

        public override PageStatePersister GetStatePersister() {
            return new Samples.AspNet.CS.StreamPageStatePersister(Page);
        }
    }
}

Imports System.Security.Permissions
Imports System.Web
Imports System.Web.UI

Namespace Samples.AspNet.VB

    <AspNetHostingPermission(SecurityAction.Demand, Level:=AspNetHostingPermissionLevel.Minimal)> _
    Public Class MyPageAdapter
       Inherits System.Web.UI.Adapters.PageAdapter


       Public Overrides Function GetStatePersister() As PageStatePersister
          Return New Samples.AspNet.VB.StreamPageStatePersister(Page)
       End Function 'GetStatePersister

    End Class

End Namespace

Compilez ces deux classes dans un assembly que vous pouvez utiliser pour exécuter un exemple, à l’aide de la ligne de commande du compilateur suivante. Vérifiez que l’assembly compilé se trouve dans le répertoire \Bin sous la racine de l’application ASP.NET.

// C:\>csc /t:library /out:C:\inetpub\wwwroot\bin\Samples.AspNet.CS.dll MyPageAdapter.cs TextFilePageStatePersister.cs
//
// C:\>

' C:\>vbc /t:library /out:C:\inetpub\wwwroot\bin\Samples.AspNet.VB.dll MyPageAdapter.vb TextFilePageStatePersister.vb
'

Enfin, pour activer l’adaptateur MyPageAdapter , vous devez créer un répertoire nommé Navigateurs sous la racine de l’application ASP.NET et inclure un fichier .browser avec des informations de configuration. L’élément <refid> dans le fichier de configuration indique que la configuration remplace les valeurs spécifiées pour le navigateur par défaut dans le fichier de configuration Default.browser. Dans cet exemple, MyPageAdapter est utilisé pour ASP.NET pages Web (où normalement aucun adaptateur n’est utilisé).

<browsers>  
    <browser refid="Default" >  
        <controlAdapters>  
            <adapter   
                controlType="System.Web.UI.Page"                              
                adapterType="Samples.AspNet.CS.MyPageAdapter" />  
        </controlAdapters>  
    </browser>  
</browsers>  

Remarques

Les requêtes et réponses HTTP sont intrinsèquement sans état. Pour conserver les informations d’état entre les requêtes HTTP, ASP.NET pages de serveur peuvent stocker Page l’état. Cet état, appelé état d’affichage, se compose de paramètres de page et de contrôle et de données qui font que la page et les contrôles apparaissent comme s’ils sont les mêmes que ceux avec lesquels l’utilisateur a vu et interagi lors de son dernier aller-retour sur le serveur. Plusieurs mécanismes existent pour stocker l’état d’affichage entre les requêtes successives sur la même page. La classe abstraite PageStatePersister représente la classe de base pour ces mécanismes de stockage d’informations d’état.

Le mécanisme de persistance de l’état d’affichage par défaut dans ASP.NET consiste à conserver les informations d’état sous la forme d’une chaîne encodée en Base64 dans un élément HTML masqué (élément avec l’attribut type défini "hidden"sur ) sur la page. Une page ASP.NET utilise un HiddenFieldPageStatePersister objet pour effectuer ce travail, en utilisant une IStateFormatter instance pour sérialiser et désérialiser les informations d’état de l’objet. Vous pouvez également stocker l’état d’affichage de vos pages dans l’objet sur le Session serveur à l’aide de la classe pour les SessionPageStatePersister clients mobiles avec une bande passante et des ressources limitées. Dans certains cas, vous pouvez désactiver complètement la persistance de l’état d’affichage. Si vous procédez ainsi, le résultat est que parfois les pages et les contrôles qui s’appuient sur la persistance de l’état ne se comportent pas correctement. Pour plus d’informations sur la gestion de l’état des pages et l’état d’affichage, consultez Vue d’ensemble de la gestion de l’état ASP.NET.

Si vous écrivez des contrôles, vous pouvez stocker les informations d’état des contrôles dans le ViewState dictionnaire, qui est un StateBag objet . Un développeur récupère l’état du contrôle via la ControlState propriété . Vous affectez des clés et des valeurs à la ViewState propriété, et l’objet Page sérialise les informations d’état entre les requêtes. Pour effectuer une gestion d’état personnalisée dans votre contrôle, remplacez les LoadViewState méthodes et .SaveViewState Toutes les informations d’état stockées dans ce dictionnaire sont perdues lorsque l’état d’affichage est désactivé par un développeur de pages. Pour atténuer ce problème, dans ASP.NET version 2.0, vous pouvez stocker les informations d’état critique dans un objet distinct, appelé état de contrôle. L’objet d’état de contrôle n’est pas affecté lorsque l’état d’affichage est désactivé par un développeur de pages. Le stockage des informations d’état dans l’objet d’état du contrôle nécessite que le contrôle remplace les LoadControlState méthodes et SaveControlState et que le contrôle soit inscrit pour stocker les informations d’état dans l’état du contrôle chaque fois que le contrôle est initialisé. Vous pouvez inscrire un contrôle pour utiliser l’état du contrôle en remplaçant la OnInit méthode et en appelant la RegisterRequiresControlState méthode . Pour plus d’informations sur l’utilisation de la ViewState propriété et de l’état du contrôle lors du développement de contrôles, consultez Développement de contrôles serveur de ASP.NET personnalisés.

Pour conserver l’état d’affichage sur les clients qui ne peuvent pas prendre en charge les mécanismes de persistance d’état d’affichage existants, vous pouvez étendre la PageStatePersister classe pour introduire vos propres méthodes de persistance d’état d’affichage, et vous pouvez utiliser des adaptateurs de page pour configurer votre application ASP.NET afin d’utiliser différents mécanismes de persistance d’état d’affichage en fonction du type de client auquel une page est servie. Les classes qui dérivent de la PageStatePersister classe doivent remplacer la méthode abstraite Save pour stocker l’état d’affichage et l’état de contrôle dans le support de persistance, et remplacer la méthode pour l’extraire Load . Si vous devez sérialiser l’état d’affichage et contrôler l’état d’une chaîne, vous pouvez utiliser l’objet IStateFormatter auquel vous accédez à l’aide de la StateFormatter propriété . Il sérialise et désérialise efficacement les informations d’état d’objet dans une chaîne encodée en Base64. Vous pouvez également remplacer la StateFormatter propriété pour fournir votre propre mécanisme de sérialisation d’état d’objet.

Constructeurs

Propriétés

Méthodes

S’applique à

Voir aussi

• ObjectStateFormatter
• LosFormatter
• Pair