PageStatePersister Classe

Definizione

Fornisce le funzionalità di base per i meccanismi di persistenza dello stato di visualizzazione disponibili in ASP.NET.Provides the base functionality for ASP.NET view state persistence mechanisms.

public ref class PageStatePersister abstract
public abstract class PageStatePersister
type PageStatePersister = class
Public MustInherit Class PageStatePersister
Ereditarietà
PageStatePersister
Derivato

Esempio

Nell'esempio di codice riportato di seguito viene illustrato come creare un PageStatePersister oggetto che consente di salvare lo stato di visualizzazione e controllo sul server Web.The following code example demonstrates how to create a PageStatePersister object that saves view and control state on the Web server. StreamPageStatePersisterViene illustrato come eseguire l'override Load dei Save metodi e per estrarre e salvare le informazioni sullo stato di visualizzazione.The StreamPageStatePersister demonstrates how to override the Load and Save methods to extract and save view state information. Poiché i meccanismi di persistenza dello stato sono correlati al rendering adattivo e alle funzionalità client, MyPageAdapter viene fornita la classe per attivare StreamPageStatePersister per un'applicazione ASP.NET.Because the state persistence mechanisms are related to adaptive rendering and client capabilities, the MyPageAdapter class is provided to activate the StreamPageStatePersister for an ASP.NET application. Infine, viene fornito un file di funzionalità del browser (con estensione browser) per abilitare l' MyPageAdapter Adapter per una classe specifica di client (in questo caso, il Web browser predefinito).Finally, a browser capabilities (.browser) file is provided to enable the MyPageAdapter adapter for a specific class of clients (in this case, the default Web browser).

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 PageAdapter classe che restituisce un'istanza di StreamPageStatePersister , che viene utilizzata per salvare in modo permanente lo stato di visualizzazione e controllo per una pagina Web ASP.NET.The following code example demonstrates how to create a PageAdapter class that returns an instance of StreamPageStatePersister, which is used to persist view and control state for an ASP.NET Web page.

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.Compile these two classes into an assembly that you can use to run a sample, using the following compiler command line. Verificare che l'assembly compilato si trovi nella directory \Bin sotto la radice dell'applicazione ASP.NET.Ensure that the compiled assembly is in the \Bin directory underneath the ASP.NET application root.

// 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' MyPageAdapter Adapter, è necessario creare una directory denominata Browsers sotto la radice dell'applicazione ASP.NET e includere un file con estensione browser con le informazioni di configurazione.Finally, to enable the MyPageAdapter adapter, you must create a directory named Browsers underneath the ASP.NET application root, and include a .browser file with configuration information. L' <refid> elemento nel file di configurazione indica che la configurazione sostituisce i valori specificati per il browser predefinito nel file di configurazione default. browser.The <refid> element in the configuration file indicates that the configuration overrides the values specified for the default browser in the Default.browser configuration file. In questo esempio, MyPageAdapter viene usato per le pagine Web ASP.NET (dove normalmente non viene usato alcun Adapter).In this example, MyPageAdapter is used for ASP.NET Web pages (where normally no adapter is used).

<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.The HTTP requests and responses are inherently stateless. Per mantenere le informazioni sullo stato tra le richieste HTTP, le pagine del server ASP.NET possono archiviare Page lo stato.To maintain state information between HTTP requests, ASP.NET server pages can store Page state. Questo stato, denominato stato di visualizzazione, è costituito dalle impostazioni di pagina e controllo e dai dati che rendono la pagina e i controlli visualizzati come se fossero gli stessi che l'utente ha visto e interagito nell'ultimo round trip al server.This state, called view state, consists of page and control settings and data that make the page and controls appear as if they are the same ones that the user saw and interacted with on their last round trip to the server. Esistono diversi meccanismi per archiviare lo stato di visualizzazione tra le richieste successive alla stessa pagina.Several mechanisms exist to store view state between successive requests to the same page. La PageStatePersister classe astratta rappresenta la classe di base per questi meccanismi di archiviazione delle informazioni sullo stato.The abstract PageStatePersister class represents the base class for these state information storage mechanisms.

Il meccanismo di persistenza dello stato di visualizzazione predefinito in ASP.NET è quello di mantenere le informazioni sullo stato sotto forma di stringa con codifica Base64 in un elemento HTML nascosto, ovvero un elemento con l' type attributo impostato "hidden" su, nella pagina.The default view state persistence mechanism in ASP.NET is to maintain the state information as a Base64-encoded string in a hidden HTML element (an element with the type attribute set to "hidden") on the page. Una pagina ASP.NET usa un HiddenFieldPageStatePersister oggetto per eseguire questa operazione, usando un' IStateFormatter istanza per serializzare e deserializzare le informazioni sullo stato dell'oggetto.An ASP.NET page uses a HiddenFieldPageStatePersister object to perform this work, using an IStateFormatter instance to serialize and deserialize object state information. In alternativa, è possibile archiviare lo stato di visualizzazione per le pagine nell' Session oggetto nel server usando la SessionPageStatePersister classe per i client mobili con larghezza di banda e risorse limitate.Alternately, you can store the view state for your pages in the Session object on the server using the SessionPageStatePersister class for mobile clients with limited bandwidth and resources. In alcuni casi, è possibile disabilitare completamente la persistenza dello stato di visualizzazione.In some cases, you might disable view state persistence altogether. In tal caso, il risultato è che talvolta le pagine e i controlli basati sulla persistenza dello stato non si comportano correttamente.If you do this, the result is that sometimes pages and controls that rely on state persistence do not behave correctly. Per ulteriori informazioni sulla gestione dello stato della pagina e sullo stato di visualizzazione, vedere Panoramica della gestione dello stato di ASP.NET.For more information about page state management and view state, see ASP.NET State Management Overview.

Se si scrivono controlli, è possibile archiviare le informazioni sullo stato per i controlli nel ViewState dizionario, ovvero un StateBag oggetto.If you are writing controls, you can store state information for the controls in the ViewState dictionary, which is a StateBag object. Uno sviluppatore può recuperare lo stato del controllo tramite la ControlState Proprietà.A developer would retrieve the control state through the ControlState property. Si assegnano chiavi e valori alla ViewState proprietà e l' Page oggetto serializza le informazioni sullo stato tra le richieste.You assign keys and values to the ViewState property, and the Page object serializes the state information between requests. Per eseguire la gestione dello stato personalizzata nel controllo, eseguire l'override dei LoadViewState SaveViewState metodi e.To perform custom state handling in your control, override the LoadViewState and SaveViewState methods. Tutte le informazioni sullo stato archiviate in questo dizionario vengono perse quando lo stato di visualizzazione è disabilitato da uno sviluppatore di pagine.Any state information that is stored in this dictionary is lost when view state is disabled by a page developer. Per attenuare questo problema, in ASP.NET versione 2,0 è possibile archiviare le informazioni di stato critiche in un oggetto separato, denominato stato del controllo.To mitigate this, in ASP.NET version 2.0 you can store critical state information in a separate object, called control state. L'oggetto stato del controllo non è influenzato quando lo stato di visualizzazione è disabilitato da uno sviluppatore di pagine.The control state object is not affected when view state is disabled by a page developer. L'archiviazione delle informazioni sullo stato nell'oggetto stato del controllo richiede che il controllo esegua l'override dei LoadControlState SaveControlState metodi e e che il controllo sia registrato per archiviare le informazioni sullo stato nello stato del controllo ogni volta che viene inizializzato il controllo.Storing state information in the control state object requires that the control override the LoadControlState and SaveControlState methods and that the control be registered to store state information in control state every time the control is initialized. È possibile registrare un controllo per usare lo stato del controllo eseguendo l'override del OnInit metodo e chiamando il RegisterRequiresControlState metodo.You can register a control to use control state by overriding the OnInit method and calling the RegisterRequiresControlState method. Per ulteriori informazioni sull'utilizzo ViewState dello stato della proprietà e del controllo durante lo sviluppo di controlli, vedere sviluppo di controlli server ASP.NET personalizzati.For more information about using the ViewState property and control state when developing controls, see Developing Custom ASP.NET Server Controls.

Per mantenere lo stato di visualizzazione sui client che non sono in grado di supportare i meccanismi di persistenza dello stato di visualizzazione esistenti, è possibile estendere la PageStatePersister classe per introdurre metodi di persistenza dello stato di visualizzazione personalizzati ed è possibile usare gli adattatori di pagina per configurare l'applicazione ASP.NET in modo da usare meccanismi di persistenza dello stato di visualizzazione diversi in base al tipo di client a cui viene gestitaTo maintain view state on clients that cannot support the existing view state persistence mechanisms, you can extend the PageStatePersister class to introduce your own view state persistence methods, and you can use page adapters to configure your ASP.NET application to use different view state persistence mechanisms based on the type of client to which a page is served. Le classi che derivano dalla PageStatePersister classe devono eseguire l'override del metodo astratto per archiviare lo stato di Save visualizzazione e lo stato del controllo nel supporto di persistenza ed eseguire l'override del Load metodo per estrarlo.Classes that derive from the PageStatePersister class must override the abstract Save method to store view state and control state in the persistence medium, and override the Load method to extract it. Se è necessario serializzare lo stato di visualizzazione e il controllo in una stringa, è possibile utilizzare l' IStateFormatter oggetto a cui si accede utilizzando la StateFormatter Proprietà.If you need to serialize view state and control state to a string, you can use the IStateFormatter object that is accessed using the StateFormatter property. Serializza e deserializza in modo efficiente le informazioni sullo stato dell'oggetto in una stringa con codifica Base64.It efficiently serializes and deserializes object state information to a Base64-encoded string. È anche possibile eseguire l'override della StateFormatter proprietà per fornire il proprio meccanismo di serializzazione dello stato dell'oggetto.You can also override the StateFormatter property to supply your own object state serialization mechanism.

Costruttori

PageStatePersister(Page)

Inizializza una nuova istanza della classe PageStatePersister.Initializes a new instance of the PageStatePersister class.

Proprietà

ControlState

Ottiene o imposta un oggetto che rappresenta i dati utilizzati dai controlli contenuti nell'oggetto Page corrente per la persistenza tra le richieste HTTP inviate al server Web.Gets or sets an object that represents the data that controls contained by the current Page object use to persist across HTTP requests to the Web server.

Page

Ottiene o imposta l'oggetto Page per il quale viene creato il meccanismo di persistenza dello stato di visualizzazione.Gets or sets the Page object that the view state persistence mechanism is created for.

StateFormatter

Ottiene un oggetto IStateFormatter utilizzato per serializzare e deserializzare le informazioni sullo stato contenute nelle proprietà ViewState e ControlState durante le chiamate dei metodi Save() e Load().Gets an IStateFormatter object that is used to serialize and deserialize the state information contained in the ViewState and ControlState properties during calls to the Save() and Load() methods.

ViewState

Ottiene o imposta un oggetto che rappresenta i dati utilizzati dai controlli contenuti nell'oggetto Page corrente per la persistenza tra le richieste HTTP inviate al server Web.Gets or sets an object that represents the data that controls contained by the current Page object use to persist across HTTP requests to the Web server.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
Load()

Le classi derivate eseguono l'override di questo metodo per deserializzare e caricare informazioni persistenti sullo stato quando un oggetto Page inizializza la gerarchia dei controlli.Overridden by derived classes to deserialize and load persisted state information when a Page object initializes its control hierarchy.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Save()

Le classi derivate eseguono l'override di questo metodo per serializzare informazioni persistenti sullo stato quando un oggetto Page viene scaricato dalla memoria.Overridden by derived classes to serialize persisted state information when a Page object is unloaded from memory.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a

Vedi anche