PageStatePersister Classe

Référence

Définition

Espace de noms:: System.Web.UI

Assembly:: System.Web.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit les fonctionnalités de base régissant les mécanismes de persistance de l'état d'affichage d'ASP.NET.

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. Montre StreamPageStatePersister comment remplacer les Load méthodes et Save pour extraire et enregistrer les informations d’état d’affichage. Étant donné que les mécanismes de persistance d’état sont liés aux fonctionnalités de rendu adaptatif et de client, 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 aucune carte n’est utilisée).

<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 serveur peuvent stocker Page l’état. Cet état, appelé état d’affichage, se compose des paramètres de page et de contrôle et des données qui font que la page et les contrôles apparaissent comme s’ils sont les mêmes que ceux que l’utilisateur a vus et avec lesquels il a interagi lors de son dernier aller-retour vers 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, à l’aide d’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 reposent sur la persistance d’état ne se comportent pas correctement. Pour plus d’informations sur la gestion de l’état des pages et l’état d’affichage, consultez ASP.NET Vue d’ensemble de la gestion de l’état.

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 de contrôle via la ControlState propriété . Vous attribuez 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 page. Le stockage des informations d’état dans l’objet d’état de 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 de contrôle chaque fois que le contrôle est initialisé. Vous pouvez inscrire un contrôle pour utiliser l’état de 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 de contrôle lors du développement de contrôles, consultez Développement de contrôles serveur ASP.NET personnalisés.

Pour maintenir 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 traitée. 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 l’état de contrôle dans une chaîne, vous pouvez utiliser l’objet auquel vous accédez à l’aide IStateFormatter 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

PageStatePersister(Page)

Initialise une nouvelle instance de la classe PageStatePersister.

Propriétés

ControlState	Obtient ou définit un objet qui représente les données que les contrôles contenus dans l'objet Page actuel utilisent pour la persistance à travers des requêtes HTTP au serveur Web.
Page	Obtient ou définit l'objet Page pour lequel le mécanisme de persistance de l'état d'affichage est créé.
StateFormatter	Obtient un objet IStateFormatter qui est utilisé pour sérialiser et désérialiser les informations d'état contenues dans les propriétés ViewState et ControlState lors de l'appel des méthodes Save() et Load().
ViewState	Obtient ou définit un objet qui représente les données que les contrôles contenus dans l'objet Page actuel utilisent pour la persistance à travers des requêtes HTTP au serveur Web.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
Load()	Substitué par des classes dérivées pour désérialiser et charger des informations d'état persistant lorsqu'un objet Page initialise sa hiérarchie de contrôle.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Save()	Substitué par des classes dérivées pour sérialiser des informations d'état persistant lorsqu'un objet Page est déchargé de la mémoire.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

S’applique à