PageStatePersister Classe

Definição

public ref class PageStatePersister abstract

public abstract class PageStatePersister

type PageStatePersister = class

Public MustInherit Class PageStatePersister

Herança

Object

PageStatePersister

Derivado

System.Web.UI.HiddenFieldPageStatePersister

System.Web.UI.SessionPageStatePersister

Exemplos

O exemplo de código seguinte demonstra como criar um PageStatePersister objeto que guarde o estado de visualização e controlo no servidor Web. Demonstra StreamPageStatePersister como substituir os Load métodos e Save para extrair e guardar informação do estado da vista. Como os mecanismos de persistência de estado estão relacionados com renderização adaptativa e capacidades do cliente, a classe MyPageAdapter é fornecida para ativar o StreamPageStatePersister para uma aplicação ASP.NET. Finalmente, é fornecido um ficheiro de capacidades do navegador (.browser) para ativar o MyPageAdapter adaptador para uma classe específica de clientes (neste caso, o navegador Web predefinido).

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

O seguinte exemplo de código demonstra como criar uma classe PageAdapter que devolve uma instância de StreamPageStatePersister, que é usada para persistir o estado de visualização e controlo de uma página 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

Compila estas duas classes numa assembly que possas usar para executar um exemplo, usando a seguinte linha de comandos do compilador. Certifique-se de que o assembly compilado está no diretório \Bin por baixo da raiz da aplicação 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
'

Finalmente, para ativar o adaptador MyPageAdapter, deve criar um diretório chamado Browsers por baixo da raiz da aplicação ASP.NET e incluir um ficheiro .browser com informações de configuração. O <refid> elemento no ficheiro de configuração indica que a configuração sobrepõe os valores especificados para o navegador predefinido no ficheiro de configuração Default.browser. Neste exemplo, MyPageAdapter é usado para ASP.NET páginas Web (onde normalmente não é usado adaptador).

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

Observações

Os pedidos e respostas HTTP são inerentemente sem estado. Para manter a informação de estado entre pedidos HTTP, ASP.NET páginas do servidor podem armazenar Page estado. Este estado, chamado estado de visualização, consiste em definições de página e controlo e dados que fazem com que a página e os controlos pareçam os mesmos que o utilizador viu e com que interagiu na sua última viagem de ida e volta ao servidor. Existem vários mecanismos para armazenar o estado da vista entre pedidos sucessivos na mesma página. A classe abstrata PageStatePersister representa a classe base para estes mecanismos de armazenamento de informação de estado.

O mecanismo padrão de persistência do estado da vista no ASP.NET é manter a informação do estado como uma cadeia codificada em Base64 num elemento HTML oculto (um elemento com o atributo type definido para "hidden") na página. Uma página ASP.NET utiliza um objeto HiddenFieldPageStatePersister para realizar este trabalho, usando uma instância IStateFormatter para serializar e desserializar informação do estado do objeto. Alternativamente, podes armazenar o estado da visualização das tuas páginas no Session objeto no servidor usando a SessionPageStatePersister classe para clientes móveis com largura de banda e recursos limitados. Em alguns casos, pode desativar completamente a persistência do estado da vista. Se fizeres isto, o resultado é que, por vezes, páginas e controlos que dependem da persistência de estado não se comportam corretamente. Para mais informações sobre a gestão do estado da página e ver estado, consulte ASP.NET Visão Geral da Gestão do Estado.

Se estiver a escrever controlos, pode armazenar informação de estado dos controlos no ViewState dicionário, que é um StateBag objeto. Um promotor recuperaria o estado de controlo através da ControlState propriedade. Atribuis chaves e valores à ViewState propriedade, e o Page objeto serializa a informação de estado entre pedidos. Para realizar um tratamento personalizado de estados no seu controlo, sobrescrita os LoadViewState métodos e (e SaveViewState métodos). Qualquer informação de estado armazenada neste dicionário perde-se quando o estado de visualização é desativado por um programador de páginas. Para mitigar isto, no ASP.NET versão 2.0 pode armazenar informação de estado crítico num objeto separado, chamado estado de controlo. O objeto estado de controlo não é afetado quando o estado de visualização é desativado por um programador de página. Armazenar informação de estado no objeto de estado de controlo requer que o controlo sobreponha os LoadControlState métodos and SaveControlState e que o controlo seja registado para armazenar informação de estado no estado de controlo sempre que o controlo for inicializado. Pode registar um controlo para usar o estado de controlo sobrescrevendo o OnInit método e chamando o RegisterRequiresControlState método. Para mais informações sobre a utilização da propriedade e do estado de controlo ViewState ao desenvolver controlos, consulte Developing Custom ASP.NET Server Controls.

Para manter o estado de vista em clientes que não suportam os mecanismos de persistência de estado de vista existentes, pode estender a classe PageStatePersister para introduzir os seus próprios métodos de persistência de estado de vista, e pode usar adaptadores de página para configurar a sua aplicação de ASP.NET para usar diferentes mecanismos de persistência de estado de vista consoante o tipo de cliente a que uma página é servida. As classes que derivam da PageStatePersister classe devem sobrepor o método abstrato Save para armazenar o estado da vista e o estado de controlo no meio de persistência, e sobrepor o Load método para o extrair. Se precisares de serializar o estado da vista e o estado de controlo para uma string, podes usar o IStateFormatter objeto acedido usando a StateFormatter propriedade. Serializa e desserializa eficientemente a informação do estado do objeto para uma cadeia codificada em Base64. Também pode sobrescrever a StateFormatter propriedade para fornecer o seu próprio mecanismo de serialização do estado do objeto.

Ver também

• ObjectStateFormatter
• LosFormatter
• Pair