Compartir vía


StateManagedCollection Clase

Definición

Proporciona una clase base para todas las colecciones fuertemente tipadas que administran objetos 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
Herencia
StateManagedCollection
Derivado
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestra cómo derivar una clase de colección fuertemente tipada de StateManagedCollection para contener IStateManager objetos . En este ejemplo, CycleCollection se deriva para contener instancias de la clase abstracta Cycle , que puede ser o Bicycle Tricycle objetos. La Cycle clase implementa la IStateManager interfaz porque almacena el valor de la CycleColor propiedad en estado de vista.

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

Comentarios

La StateManagedCollection clase es la clase base para todas las colecciones fuertemente tipadas que almacenan IStateManager elementos, incluidos DataControlFieldCollection, ParameterCollection, StyleCollection, TreeNodeBindingCollection, y otros. La StateManagedCollection colección administra su propio estado, así como el estado de los elementos que contiene. Por lo tanto, una llamada para IStateManager.SaveViewState guardar el estado de la colección y el estado de todos los elementos contenidos actualmente en la colección.

Los métodos más importantes que se deben tener en cuenta al derivar de la StateManagedCollection clase son CreateKnownType, GetKnownTypes, OnValidate, SetDirtyy SetDirtyObject. Los CreateKnownType métodos y GetKnownTypes se usan para almacenar un índice en estado de vista para el tipo de un elemento contenido. El almacenamiento de un índice en lugar de un nombre de tipo completo mejora el rendimiento. Se OnValidate llama al método cada vez que se manipulan los elementos de la colección y valida los elementos según las reglas de negocios. Actualmente, la implementación del OnValidate método prohíbe null que los objetos se almacenen en la colección; sin embargo, puede invalidar este método para definir su propio comportamiento de validación en un tipo derivado. El SetDirty método obliga a serializar toda la colección para ver el estado, en lugar de simplemente serializar los cambios realizados en el estado desde la última vez que se cargó. El SetDirtyObject método es un método abstracto que puede implementar para realizar este mismo comportamiento en el nivel de elemento.

Importante

StateManagedCollection almacena nombres de tipo calificado para ensamblados de los elementos de la colección en estado de vista. Un visitante del sitio podría descodificar el estado de vista y recuperar el nombre del tipo. Si este escenario crea un problema de seguridad en el sitio web, puede cifrar manualmente el nombre de tipo antes de colocarlo en el estado de vista.

Constructores

StateManagedCollection()

Inicializa una nueva instancia de la clase StateManagedCollection.

Propiedades

Count

Obtiene el número de elementos incluidos en la colección StateManagedCollection.

Métodos

Clear()

Quita todos los elementos de la colección StateManagedCollection.

CopyTo(Array, Int32)

Copia los elementos de la colección StateManagedCollection en una matriz a partir de un índice de matriz concreto.

CreateKnownType(Int32)

Cuando se reemplaza en una clase derivada, crea una instancia de una clase que implementa IStateManager. El tipo de objeto creado se basa en el miembro especificado de la colección devuelto por el método GetKnownTypes().

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetEnumerator()

Devuelve un iterador que permite recorrer en iteración la colección StateManagedCollection.

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetKnownTypes()

Cuando se reemplaza en una clase derivada, obtiene una matriz de tipos IStateManager que la colección StateManagedCollection puede contener.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
OnClear()

Cuando se reemplaza en una clase derivada, realiza un trabajo adicional antes de que el método Clear() quite todos los elementos de la colección.

OnClearComplete()

Cuando se reemplaza en una clase derivada, realiza un trabajo adicional después de que el método Clear() termine de quitar todos los elementos de la colección.

OnInsert(Int32, Object)

Cuando se reemplaza en una clase derivada, realiza un trabajo adicional antes de que los métodos IList.Insert(Int32, Object) o IList.Add(Object) agreguen un elemento a la colección.

OnInsertComplete(Int32, Object)

Cuando se reemplaza en una clase derivada, realiza un trabajo adicional después de que los métodos IList.Insert(Int32, Object) o IList.Add(Object) agreguen un elemento a la colección.

OnRemove(Int32, Object)

Cuando se reemplaza en una clase derivada, realiza un trabajo adicional antes de que los métodos IList.Remove(Object) o IList.RemoveAt(Int32) quiten el elemento especificado de la colección.

OnRemoveComplete(Int32, Object)

Cuando se reemplaza en una clase derivada, realiza un trabajo adicional después de que los métodos IList.Remove(Object) o IList.RemoveAt(Int32) quiten el elemento especificado de la colección.

OnValidate(Object)

Cuando se reemplaza en una clase derivada, valida un elemento de la colección StateManagedCollection.

SetDirty()

Obliga a serializar la colección StateManagedCollection completa en el estado de vista.

SetDirtyObject(Object)

Cuando se reemplaza en una clase derivada, indica a un object incluido en la colección que registre su estado completo en el estado de vista, en lugar de registrar solo la información correspondiente a los cambios.

ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)

Implementaciones de interfaz explícitas

ICollection.Count

Obtiene el número de elementos incluidos en la colección StateManagedCollection.

ICollection.IsSynchronized

Obtiene un valor que indica si la colección StateManagedCollection está sincronizada (seguro para subprocesos). Este método devuelve false en todos los casos.

ICollection.SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a la colección StateManagedCollection. Este método devuelve null en todos los casos.

IEnumerable.GetEnumerator()

Devuelve un iterador que permite recorrer en iteración la colección StateManagedCollection.

IList.Add(Object)

Agrega un elemento a la colección StateManagedCollection.

IList.Clear()

Quita todos los elementos de la colección StateManagedCollection.

IList.Contains(Object)

Determina si la colección StateManagedCollection contiene un valor específico.

IList.IndexOf(Object)

Determina el índice de un elemento especificado en la colección StateManagedCollection.

IList.Insert(Int32, Object)

Inserta un elemento en el índice especificado de la colección StateManagedCollection.

IList.IsFixedSize

Obtiene un valor que indica si la colección StateManagedCollection tiene un tamaño fijo. Este método devuelve false en todos los casos.

IList.IsReadOnly

Obtiene un valor que indica si la colección StateManagedCollection es de solo lectura.

IList.Item[Int32]

Obtiene el elemento IStateManager en el índice especificado.

IList.Remove(Object)

Quita la primera aparición del objeto especificado de la colección StateManagedCollection.

IList.RemoveAt(Int32)

Quita el elemento IStateManager en el índice especificado.

IStateManager.IsTrackingViewState

Obtiene un valor que indica si la colección StateManagedCollection está guardando los cambios en su estado de vista.

IStateManager.LoadViewState(Object)

Restaura el estado de vista previamente guardado de la colección StateManagedCollection y de los elementos IStateManager que contiene.

IStateManager.SaveViewState()

Guarda los cambios realizados en la colección StateManagedCollection y en cada objeto IStateManager que contiene desde el momento en que la página se devolvió al servidor.

IStateManager.TrackViewState()

Hace que la colección StateManagedCollection y cada uno de los objetos IStateManager que contiene realicen un seguimiento de los cambios en el estado de vista para que se puedan conservar entre distintas solicitudes de la misma página.

Métodos de extensión

Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.

OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.

AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.

Se aplica a

Consulte también