PageStatePersister Classe

Definizione

public ref class PageStatePersister abstract

public abstract class PageStatePersister

type PageStatePersister = class

Public MustInherit Class PageStatePersister

Ereditarietà

Object

PageStatePersister

Derivato

System.Web.UI.HiddenFieldPageStatePersister

System.Web.UI.SessionPageStatePersister

Esempio

Nell'esempio di codice seguente viene illustrato come creare un PageStatePersister oggetto che salva lo stato di visualizzazione e controllo nel server Web. StreamPageStatePersister Illustra come eseguire l'override dei Load metodi e Save per estrarre e salvare le informazioni sullo stato di visualizzazione. Poiché i meccanismi di persistenza dello stato sono correlati al rendering adattivo e alle funzionalità client, la MyPageAdapter classe viene fornita per attivare StreamPageStatePersister per un'applicazione ASP.NET. Infine, viene fornito un file di funzionalità del browser (con estensione browser) per abilitare l'adattatore MyPageAdapter per una classe specifica di client (in questo caso, il Web browser predefinito).

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

Nell'esempio di codice seguente viene illustrato come creare una classe che restituisce un'istanza PageAdapter di , usata per rendere persistente lo stato di StreamPageStatePersistervisualizzazione e controllo per una pagina 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

Compilare queste due classi in un assembly che è possibile usare per eseguire un esempio usando la riga di comando del compilatore seguente. Assicurarsi che l'assembly compilato si trova nella directory \Bin sotto la radice dell'applicazione 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
'

Infine, per abilitare l'adattatore MyPageAdapter , è necessario creare una directory denominata Browser sotto la radice dell'applicazione ASP.NET e includere un file con estensione browser con informazioni di configurazione. L'elemento <refid> nel file di configurazione indica che la configurazione esegue l'override dei valori specificati per il browser predefinito nel file di configurazione Default.browser. In questo esempio viene MyPageAdapter usato per ASP.NET pagine Web (in cui in genere non viene usato alcun adattatore).

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

Commenti

Le richieste e le risposte HTTP sono intrinsecamente senza stato. Per mantenere le informazioni sullo stato tra le richieste HTTP, ASP.NET pagine del server possono archiviare Page lo stato. Questo stato, denominato stato di visualizzazione, è costituito da impostazioni di pagina e controllo e dati che rendono la pagina e i controlli visualizzati come se fossero gli stessi con cui l'utente ha visto e interagito con l'ultimo round trip al server. Esistono diversi meccanismi per archiviare lo stato di visualizzazione tra le richieste successive alla stessa pagina. La classe astratta PageStatePersister rappresenta la classe base per questi meccanismi di archiviazione delle informazioni sullo stato.

Il meccanismo di persistenza dello stato di visualizzazione predefinito in ASP.NET consiste nel mantenere le informazioni sullo stato come stringa con codifica Base64 in un elemento HTML nascosto (un elemento con l'attributo type impostato su "hidden") nella pagina. Una pagina ASP.NET usa un HiddenFieldPageStatePersister oggetto per eseguire questa operazione, utilizzando un'istanza IStateFormatter per serializzare e deserializzare le informazioni sullo stato dell'oggetto. In alternativa, è possibile archiviare lo stato di visualizzazione per le pagine nell'oggetto Session nel server usando la SessionPageStatePersister classe per i client mobili con larghezza di banda e risorse limitate. In alcuni casi, è possibile disabilitare completamente la persistenza dello stato di visualizzazione. In questo caso, il risultato è che a volte pagine e controlli che si basano sulla persistenza dello stato non si comportano correttamente. Per altre informazioni sulla gestione dello stato della pagina e sullo stato di visualizzazione, vedere ASP.NET Panoramica di Gestione stato.

Se si scrivono controlli, è possibile archiviare le informazioni sullo stato per i controlli nel ViewState dizionario, ovvero un StateBag oggetto . Uno sviluppatore recupera lo stato del controllo tramite la ControlState proprietà . Si assegnano chiavi e valori alla ViewState proprietà e l'oggetto Page serializza le informazioni sullo stato tra le richieste. Per eseguire la gestione dello stato personalizzata nel controllo, eseguire l'override dei LoadViewState metodi e SaveViewState . Tutte le informazioni sullo stato archiviate in questo dizionario vengono perse quando lo stato di visualizzazione viene disabilitato da uno sviluppatore di pagine. Per attenuare questo problema, in ASP.NET versione 2.0 è possibile archiviare informazioni sullo stato critico in un oggetto separato, denominato stato del controllo. L'oggetto stato del controllo non è interessato quando lo stato di visualizzazione è disabilitato da uno sviluppatore di pagine. L'archiviazione delle informazioni sullo stato nell'oggetto stato del controllo richiede che il controllo e i metodi e SaveControlState che il controllo sia registrato per archiviare LoadControlState le informazioni sullo stato del controllo ogni volta che il controllo viene inizializzato. È possibile registrare un controllo per usare lo stato del controllo eseguendo l'override del OnInit metodo e chiamando il RegisterRequiresControlState metodo . Per altre informazioni sull'uso della ViewState proprietà e dello stato del controllo durante lo sviluppo di controlli, vedere Sviluppo di controlli server ASP.NET personalizzati.

Per mantenere lo stato di visualizzazione nei client che non supportano i meccanismi di persistenza dello stato di visualizzazione esistente, è possibile estendere la PageStatePersister classe per introdurre metodi di persistenza dello stato di visualizzazione personalizzati ed è possibile usare adattatori di pagina per configurare l'applicazione ASP.NET per usare meccanismi di persistenza dello stato di visualizzazione diversi in base al tipo di client a cui viene servita una pagina. Le classi che derivano dalla classe devono eseguire l'override del PageStatePersister metodo astratto Save per archiviare lo stato di visualizzazione e lo stato del controllo nel supporto di persistenza ed eseguire l'override del Load metodo per estrarlo. Se è necessario serializzare lo stato di visualizzazione e lo stato di controllo in una stringa, è possibile utilizzare l'oggetto IStateFormatter a cui si accede usando la StateFormatter proprietà . Serializza e deserializza in modo efficiente le informazioni sullo stato dell'oggetto in una stringa con codifica Base64. È anche possibile eseguire l'override della StateFormatter proprietà per fornire il meccanismo di serializzazione dello stato dell'oggetto.

Vedi anche

• ObjectStateFormatter
• LosFormatter
• Pair