StateManagedCollection Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Web.UI
Assembly:
System.Web.dll

Fornisce una classe di base per tutte le raccolte fortemente tipizzate che gestiscono oggetti IStateManager.

public ref class StateManagedCollection abstract : System::Collections::IList, System::Web::UI::IStateManager
public abstract class StateManagedCollection : System.Collections.IList, System.Web.UI.IStateManager
type StateManagedCollection = class
    interface IList
    interface ICollection
    interface IEnumerable
    interface IStateManager
Public MustInherit Class StateManagedCollection
Implements IList, IStateManager
Ereditarietà
Object
StateManagedCollection
Derivato
Implementazioni
ICollection IEnumerable IList IStateManager

Esempio

Nell'esempio di codice seguente viene illustrato come derivare una classe di raccolta fortemente tipizzata da StateManagedCollection per contenere IStateManager oggetti. In questo esempio, viene CycleCollection derivato per contenere istanze della classe astratta Cycle , che può essere o Bicycle Tricycle oggetti. La Cycle classe implementa l'interfaccia perché archivia il IStateManager valore della proprietà nello stato di CycleColor visualizzazione.

namespace Samples.AspNet.CS.Controls {

    using System;
    using System.Security.Permissions;
    using System.Collections;
    using System.ComponentModel;
    using System.Drawing;           
    using System.Web;
    using System.Web.UI;            
    //////////////////////////////////////////////////////////////
    //
    // The strongly typed CycleCollection class is a collection
    // that contains Cycle class instances, which implement the
    // IStateManager interface.
    //
    //////////////////////////////////////////////////////////////
    [AspNetHostingPermission(SecurityAction.Demand, 
        Level=AspNetHostingPermissionLevel.Minimal)]
    public sealed class CycleCollection : StateManagedCollection {
        
        private static readonly Type[] _typesOfCycles 
            = new Type[] { typeof(Bicycle), typeof(Tricycle) };

        protected override object CreateKnownType(int index) {
            switch(index) {
                case 0:
                    return new Bicycle();
                case 1:
                    return new Tricycle();                    
                default:
                    throw new ArgumentOutOfRangeException("Unknown Type");
            }            
        }

        protected override Type[] GetKnownTypes() {
            return _typesOfCycles;
        }

        protected override void SetDirtyObject(object o) {
            ((Cycle)o).SetDirty();
        }
    }
    //////////////////////////////////////////////////////////////
    //
    // The abstract Cycle class represents bicycles and tricycles.
    //
    //////////////////////////////////////////////////////////////
    public abstract class Cycle : IStateManager {

        protected internal Cycle(int numWheels) : this(numWheels, "Red"){ }
        
        protected internal Cycle(int numWheels, String color) {    
            numberOfWheels = numWheels;
            CycleColor = color;
        }
        
        private int numberOfWheels = 0;
        public int NumberOfWheels {
            get { return numberOfWheels; }
        }
        
        public string CycleColor {
            get { 
                object o = ViewState["Color"];
                return (null == o) ? String.Empty : o.ToString() ;
            }
            set {
                ViewState["Color"] = value;            
            }        
        }

        internal void SetDirty() {
            ViewState.SetDirty(true);
        }
        
        // Because Cycle does not derive from Control, it does not 
        // have access to an inherited view state StateBag object.
        private StateBag viewState;
        private StateBag ViewState {
            get {
                if (viewState == null) {
                    viewState = new StateBag(false);
                    if (isTrackingViewState) {
                        ((IStateManager)viewState).TrackViewState();
                    }
                }
                return viewState;
            }
        }

        // The IStateManager implementation.
        private bool isTrackingViewState;
        bool IStateManager.IsTrackingViewState {
            get {
                return isTrackingViewState;
            }
        }

        void IStateManager.LoadViewState(object savedState) {
            object[] cycleState = (object[]) savedState;
            
            // In SaveViewState, an array of one element is created.
            // Therefore, if the array passed to LoadViewState has 
            // more than one element, it is invalid.
            if (cycleState.Length != 1) {
                throw new ArgumentException("Invalid Cycle View State");
            }
            
            // Call LoadViewState on the StateBag object.
            ((IStateManager)ViewState).LoadViewState(cycleState[0]);
        }

        // Save the view state by calling the StateBag's SaveViewState
        // method.
        object IStateManager.SaveViewState() {
            object[] cycleState = new object[1];

            if (viewState != null) {
                cycleState[0] = ((IStateManager)viewState).SaveViewState();
            }
            return cycleState;
        }

        // Begin tracking view state. Check the private variable, because 
        // if the view state has not been accessed or set, then it is not  
        // being used and there is no reason to store any view state.
        void IStateManager.TrackViewState() {
            isTrackingViewState = true;
            if (viewState != null) {
                ((IStateManager)viewState).TrackViewState();
            }
        }        
    }

    public sealed class Bicycle : Cycle {
    
        // Create a red Cycle with two wheels.
        public Bicycle() : base(2) {}    
    }
    
    public sealed class Tricycle : Cycle {
    
        // Create a red Cycle with three wheels.
        public Tricycle() : base(3) {}
    }
}

Imports System.Security.Permissions
Imports System.Collections
Imports System.ComponentModel
Imports System.Drawing
Imports System.Web
Imports System.Web.UI
 
Namespace Samples.AspNet.VB.Controls
    '////////////////////////////////////////////////////////////
    '
    ' The strongly typed CycleCollection class is a collection
    ' that contains Cycle class instances, which implement the
    ' IStateManager interface.
    '
    '////////////////////////////////////////////////////////////
    <AspNetHostingPermission(SecurityAction.Demand, _
        Level:=AspNetHostingPermissionLevel.Minimal)> _
                   Public NotInheritable Class CycleCollection
        Inherits StateManagedCollection

        Private Shared _typesOfCycles() As Type = _
            {GetType(Bicycle), GetType(Tricycle)}

        Protected Overrides Function CreateKnownType(ByVal index As Integer) As Object
            Select Case index
                Case 0
                    Return New Bicycle()
                Case 1
                    Return New Tricycle()
                Case Else
                    Throw New ArgumentOutOfRangeException("Unknown Type")
            End Select

        End Function


        Protected Overrides Function GetKnownTypes() As Type()
            Return _typesOfCycles

        End Function


        Protected Overrides Sub SetDirtyObject(ByVal o As Object)
            CType(o, Cycle).SetDirty()

        End Sub
    End Class
    '////////////////////////////////////////////////////////////
    '
    ' The abstract Cycle class represents bicycles and tricycles.
    '
    '////////////////////////////////////////////////////////////

    MustInherit Public Class Cycle
        Implements IStateManager


        Friend Protected Sub New(ByVal numWheels As Integer) 
            MyClass.New(numWheels, "Red")

        End Sub

        Friend Protected Sub New(ByVal numWheels As Integer, ByVal color As String) 
            numOfWheels = numWheels
            CycleColor = color

        End Sub

        Private numOfWheels As Integer = 0    
        Public ReadOnly Property NumberOfWheels() As Integer 
            Get
                Return numOfWheels
            End Get
        End Property 

        Public Property CycleColor() As String 
            Get
                Dim o As Object = ViewState("Color")
                If o Is Nothing Then 
                    Return String.Empty
                Else  
                    Return o.ToString()
                End If            
            End Get
            Set
                ViewState("Color") = value
            End Set
        End Property


        Friend Sub SetDirty() 
            ViewState.SetDirty(True)

        End Sub

        ' Because Cycle does not derive from Control, it does not 
        ' have access to an inherited view state StateBag object.
        Private cycleViewState As StateBag

        Private ReadOnly Property ViewState() As StateBag 
            Get
                If cycleViewState Is Nothing Then
                    cycleViewState = New StateBag(False)
                    If trackingViewState Then
                        CType(cycleViewState, IStateManager).TrackViewState()
                    End If
                End If
                Return cycleViewState
            End Get
        End Property

        ' The IStateManager implementation.
        Private trackingViewState As Boolean

        ReadOnly Property IsTrackingViewState() As Boolean _
            Implements IStateManager.IsTrackingViewState
            Get
                Return trackingViewState
            End Get
        End Property


        Sub LoadViewState(ByVal savedState As Object) _
            Implements IStateManager.LoadViewState
            Dim cycleState As Object() = CType(savedState, Object())

            ' In SaveViewState, an array of one element is created.
            ' Therefore, if the array passed to LoadViewState has 
            ' more than one element, it is invalid.
            If cycleState.Length <> 1 Then
                Throw New ArgumentException("Invalid Cycle View State")
            End If

            ' Call LoadViewState on the StateBag object.
            CType(ViewState, IStateManager).LoadViewState(cycleState(0))

        End Sub


        ' Save the view state by calling the StateBag's SaveViewState
        ' method.
        Function SaveViewState() As Object Implements IStateManager.SaveViewState
            Dim cycleState(0) As Object

            If Not (cycleViewState Is Nothing) Then
                cycleState(0) = _
                CType(cycleViewState, IStateManager).SaveViewState()
            End If
            Return cycleState

        End Function


        ' Begin tracking view state. Check the private variable, because 
        ' if the view state has not been accessed or set, then it is not being 
        ' used and there is no reason to store any view state.
        Sub TrackViewState() Implements IStateManager.TrackViewState
            trackingViewState = True
            If Not (cycleViewState Is Nothing) Then
                CType(cycleViewState, IStateManager).TrackViewState()
            End If

        End Sub
    End Class


    Public NotInheritable Class Bicycle
        Inherits Cycle


        ' Create a red Cycle with two wheels.
        Public Sub New()
            MyBase.New(2)

        End Sub
    End Class

    Public NotInheritable Class Tricycle
        Inherits Cycle


        ' Create a red Cycle with three wheels.
        Public Sub New()
            MyBase.New(3)

        End Sub
    End Class
End Namespace

Commenti

La StateManagedCollection classe è la classe di base per tutte le raccolte fortemente tipizzata che archivia IStateManager elementi, tra cui DataControlFieldCollection, ParameterCollectionStyleCollection, TreeNodeBindingCollection, e altri. La StateManagedCollection raccolta gestisce lo stato proprio e lo stato degli elementi contenuti. Pertanto, una chiamata per IStateManager.SaveViewState salvare lo stato della raccolta e lo stato di tutti gli elementi attualmente contenuti dalla raccolta.

I metodi più importanti da considerare quando derivano dalla StateManagedCollection classe sono CreateKnownType, , GetKnownTypesOnValidate, SetDirtye SetDirtyObject. I CreateKnownType metodi e GetKnownTypes vengono usati per archiviare un indice nello stato di visualizzazione per il tipo di un elemento contenuto. L'archiviazione di un indice anziché un nome di tipo completo migliora le prestazioni. Il OnValidate metodo viene chiamato ogni volta che gli elementi della raccolta vengono modificati e convalida gli elementi in base alle regole aziendali. Attualmente, l'implementazione del metodo impedisce null l'archiviazione degli oggetti nella raccolta. Tuttavia, è possibile eseguire l'override di OnValidate questo metodo per definire il comportamento di convalida in un tipo derivato. Il SetDirty metodo forza la serializzazione dell'intera raccolta per visualizzare lo stato, anziché solo serializzare le modifiche apportate allo stato dall'ultima volta che è stata caricata. Il SetDirtyObject metodo è un metodo astratto che è possibile implementare per eseguire questo stesso comportamento a livello di elemento.

Importante

StateManagedCollection archivia i nomi dei tipi qualificati dell'assembly degli elementi della raccolta nello stato di visualizzazione. Un visitatore del sito può decodificare lo stato di visualizzazione e recuperare il nome del tipo. Se questo scenario crea un problema di sicurezza nel sito Web, è possibile crittografare manualmente il nome del tipo prima di inserirlo nello stato di visualizzazione.

Costruttori

StateManagedCollection()

Inizializza una nuova istanza della classe StateManagedCollection.

Proprietà

Count

Ottiene il numero di elementi contenuti nella raccolta StateManagedCollection.

Metodi

Clear()

Rimuove tutti gli elementi dalla raccolta StateManagedCollection.
CopyTo(Array, Int32)

Copia gli elementi della raccolta StateManagedCollection in una matrice, a partire da un indice della matrice specifico.
CreateKnownType(Int32)

Quando sottoposto a override in una classe derivata, crea un'istanza di una classe che implementa IStateManager. Il tipo di oggetto creato è basato sul membro specificato della raccolta restituita dal metodo GetKnownTypes().
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetEnumerator()

Restituisce un iteratore che consente di scorrere la raccolta StateManagedCollection.
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetKnownTypes()

Quando sottoposto a override in una classe derivata, ottiene una matrice di tipi IStateManager che possono essere inclusi nella raccolta StateManagedCollection.
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
OnClear()

Quando sottoposto a override in una classe derivata, esegue ulteriori operazioni prima che il metodo Clear() rimuova tutti gli elementi dalla raccolta.
OnClearComplete()

Quando sottoposto a override in una classe derivata, esegue ulteriori operazioni dopo che il metodo Clear() ha completato la rimozione di tutti gli elementi dalla raccolta.
OnInsert(Int32, Object)

Quando sottoposto a override in una classe derivata, esegue ulteriori operazioni prima che il metodo IList.Insert(Int32, Object) o IList.Add(Object) aggiunga un elemento alla raccolta.
OnInsertComplete(Int32, Object)

Quando sottoposto a override in una classe derivata, esegue ulteriori operazioni dopo che il metodo IList.Insert(Int32, Object) o IList.Add(Object) ha aggiunto un elemento alla raccolta.
OnRemove(Int32, Object)

Quando sottoposto a override in una classe derivata, esegue ulteriori operazioni prima che il metodo IList.Remove(Object) o IList.RemoveAt(Int32) rimuova l'elemento specificato dalla raccolta.
OnRemoveComplete(Int32, Object)

Quando sottoposto a override in una classe derivata, esegue ulteriori operazioni dopo che il metodo IList.Remove(Object) o IList.RemoveAt(Int32) ha completato la rimozione dell'elemento specificato dalla raccolta.
OnValidate(Object)

Quando sottoposto a override in una classe derivata, convalida un elemento della raccolta StateManagedCollection.
SetDirty()

Impone la serializzazione dell'intera raccolta StateManagedCollection nello stato di visualizzazione.
SetDirtyObject(Object)

Quando sottoposto a override in una classe derivata, richiede a un object incluso nella raccolta di registrare il rispettivo stato completo nello stato di visualizzazione, invece di registrare solo le informazioni relative alle modifiche.
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

ICollection.Count

Ottiene il numero di elementi contenuti nella raccolta StateManagedCollection.
ICollection.IsSynchronized

Ottiene un valore che indica se la raccolta StateManagedCollection è sincronizzata (thread-safe). Questo metodo restituisce false in tutti i casi.
ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso alla raccolta StateManagedCollection. Questo metodo restituisce null in tutti i casi.
IEnumerable.GetEnumerator()

Restituisce un iteratore che consente di scorrere la raccolta StateManagedCollection.
IList.Add(Object)

Aggiunge un elemento alla raccolta StateManagedCollection.
IList.Clear()

Rimuove tutti gli elementi dalla raccolta StateManagedCollection.
IList.Contains(Object)

Stabilisce se la raccolta StateManagedCollection contiene un valore specifico.
IList.IndexOf(Object)

Determina l'indice di un elemento specificato nella raccolta StateManagedCollection.
IList.Insert(Int32, Object)

Inserisce un elemento nella raccolta StateManagedCollection in corrispondenza dell'indice specificato.
IList.IsFixedSize

Ottiene un valore che indica se la dimensione della raccolta StateManagedCollection è fissa. Questo metodo restituisce false in tutti i casi.
IList.IsReadOnly

Ottiene un valore che indica se la raccolta StateManagedCollection è di sola lettura.
IList.Item[Int32]

Ottiene l'elemento IStateManager in corrispondenza dell'indice specificato.
IList.Remove(Object)

Rimuove la prima occorrenza dell'oggetto specificato dalla raccolta StateManagedCollection.
IList.RemoveAt(Int32)

Rimuove l'elemento IStateManager in corrispondenza dell'indice specificato.
IStateManager.IsTrackingViewState

Ottiene un valore che indica se la raccolta StateManagedCollection salva le modifiche apportate al relativo stato di visualizzazione.
IStateManager.LoadViewState(Object)

Ripristina lo stato di visualizzazione salvato in precedenza della raccolta StateManagedCollection e gli elementi IStateManager in essa contenuti.
IStateManager.SaveViewState()

Salva le modifiche apportate alla raccolta StateManagedCollection e ogni oggetto IStateManager in essa contenuto dal momento in cui è stato eseguito il postback della pagina nel server.
IStateManager.TrackViewState()

Fa in modo che la raccolta StateManagedCollection e ogni oggetto IStateManager in essa contenuto tenga traccia delle modifiche apportate al rispettivo stato di visualizzazione, in modo da consentirne il mantenimento nelle diverse richieste per la stessa pagina.

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.
OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)

Consente la parallelizzazione di una query.
AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Vedi anche