StateManagedCollection Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Fornece uma classe base para todas as coleções fortemente tipadas que gerenciam objetos IStateManager.
public ref class StateManagedCollection abstract : System::Collections::IList, System::Web::UI::IStateManagerpublic abstract class StateManagedCollection : System.Collections.IList, System.Web.UI.IStateManagertype StateManagedCollection = class
interface IList
interface ICollection
interface IEnumerable
interface IStateManagerPublic MustInherit Class StateManagedCollection
Implements IList, IStateManager- Herança
-
StateManagedCollection
- Derivado
- Implementações
Exemplos
O exemplo de código a seguir demonstra como derivar uma classe de StateManagedCollection coleção fortemente tipada para conter IStateManager objetos. Neste exemplo, o CycleCollection é derivado para conter instâncias da classe abstrata Cycle , que pode ser um Bicycle ou Tricycle objetos. A Cycle classe implementa a IStateManager interface porque armazena o valor da propriedade no estado de CycleColor exibição.
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
Comentários
A StateManagedCollection classe é a classe base para todas as coleções fortemente tipdas que armazenam IStateManager elementos, incluindo DataControlFieldCollection, ParameterCollection, StyleCollectione TreeNodeBindingCollectionoutros. A StateManagedCollection coleção gerencia seu próprio estado, bem como o estado dos elementos que contém. Portanto, uma chamada para IStateManager.SaveViewState salvar o estado da coleção e o estado de todos os elementos contidos atualmente pela coleção.
Os métodos mais importantes a serem considerados ao derivar da StateManagedCollection classe sãoCreateKnownType, e OnValidateGetKnownTypesSetDirtySetDirtyObject. Os CreateKnownType métodos e GetKnownTypes os métodos são usados para armazenar um índice no estado de exibição para o tipo de um elemento contido. Armazenar um índice em vez de um nome de tipo totalmente qualificado melhora o desempenho. O OnValidate método é chamado sempre que os elementos da coleção são manipulados e valida os elementos de acordo com as regras de negócios. Atualmente, a implementação do OnValidate método proíbe que objetos sejam armazenados null na coleção; no entanto, você pode substituir esse método para definir seu próprio comportamento de validação em um tipo derivado. O SetDirty método força toda a coleção a ser serializada para exibir o estado, em vez de apenas serializar as alterações feitas no estado desde a última vez em que foi carregada. O SetDirtyObject método é um método abstrato que você pode implementar para executar esse mesmo comportamento no nível do elemento.
Importante
StateManagedCollection armazena nomes de tipo qualificados para assembly dos itens de coleção no estado de exibição. Um visitante do site pode decodificar o estado de exibição e recuperar o nome do tipo. Se esse cenário criar uma preocupação de segurança em seu site, você poderá criptografar manualmente o nome do tipo antes de colocá-lo no estado de exibição.
Construtores
| StateManagedCollection() |
Inicializa uma nova instância da classe StateManagedCollection. |
Propriedades
| Count |
Obtém o número de elementos contidos na coleção StateManagedCollection. |
Métodos
| Clear() |
Remove todos os itens da coleção StateManagedCollection. |
| CopyTo(Array, Int32) |
Copia os elementos da coleção StateManagedCollection para uma matriz, começando em um índice de matriz específico. |
| CreateKnownType(Int32) |
Quando substituído em uma classe derivada, cria uma instância de uma classe que implementa IStateManager. O tipo de objeto criado se baseia no membro especificado da coleção retornada pelo método GetKnownTypes(). |
| Equals(Object) |
Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object) |
| GetEnumerator() |
Retorna um iterador que itera por meio da coleção StateManagedCollection. |
| GetHashCode() |
Serve como a função de hash padrão. (Herdado de Object) |
| GetKnownTypes() |
Quando substituído em uma classe derivada, obtém uma matriz de tipos IStateManager que a coleção StateManagedCollection pode conter. |
| GetType() |
Obtém o Type da instância atual. (Herdado de Object) |
| MemberwiseClone() |
Cria uma cópia superficial do Object atual. (Herdado de Object) |
| OnClear() |
Quando substituído em uma classe derivada, executa o trabalho adicional antes do método Clear() remover todos os itens da coleção. |
| OnClearComplete() |
Quando substituído em uma classe derivada, executa o trabalho adicional após o método Clear() terminar a remoção de todos os itens da coleção. |
| OnInsert(Int32, Object) |
Quando substituído em uma classe derivada, executa o trabalho adicional antes do método IList.Insert(Int32, Object) ou IList.Add(Object) adicionar um item à coleção. |
| OnInsertComplete(Int32, Object) |
Quando substituído em uma classe derivada, executa o trabalho adicional após o método IList.Insert(Int32, Object) ou IList.Add(Object) adicionar um item à coleção. |
| OnRemove(Int32, Object) |
Quando substituído em uma classe derivada, executa o trabalho adicional antes do método IList.Remove(Object) ou IList.RemoveAt(Int32) remover o item especificado da coleção. |
| OnRemoveComplete(Int32, Object) |
Quando substituído em uma classe derivada, executa o trabalho adicional após o método IList.Remove(Object) ou IList.RemoveAt(Int32) remover o item especificado da coleção. |
| OnValidate(Object) |
Quando substituído em uma classe derivada, valida um elemento da coleção StateManagedCollection. |
| SetDirty() |
Força a coleção StateManagedCollection inteira a ser serializada no estado de exibição. |
| SetDirtyObject(Object) |
Quando substituído em uma classe derivada, instrui um |
| ToString() |
Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object) |
Implantações explícitas de interface
| ICollection.Count |
Obtém o número de elementos contidos na coleção StateManagedCollection. |
| ICollection.IsSynchronized |
Obtém um valor que indica se a coleção StateManagedCollection é sincronizada (thread-safe). Este método retorna |
| ICollection.SyncRoot |
Obtém um objeto que pode ser usado para sincronizar o acesso à coleção StateManagedCollection. Este método retorna |
| IEnumerable.GetEnumerator() |
Retorna um iterador que itera por meio da coleção StateManagedCollection. |
| IList.Add(Object) |
Adiciona um item à coleção StateManagedCollection. |
| IList.Clear() |
Remove todos os itens da coleção StateManagedCollection. |
| IList.Contains(Object) |
Determina se a coleção StateManagedCollection contém um valor específico. |
| IList.IndexOf(Object) |
Determina o índice de um item especificado na coleção StateManagedCollection. |
| IList.Insert(Int32, Object) |
Insere um item na coleção StateManagedCollection no índice especificado. |
| IList.IsFixedSize |
Obtém um valor que indica se a coleção StateManagedCollection tem um tamanho fixo. Este método retorna |
| IList.IsReadOnly |
Obtém um valor que indica se a coleção StateManagedCollection é somente leitura. |
| IList.Item[Int32] |
Obtém o elemento IStateManager no índice especificado. |
| IList.Remove(Object) |
Remove a primeira ocorrência do objeto especificado da coleção StateManagedCollection. |
| IList.RemoveAt(Int32) |
Remove o elemento IStateManager no índice especificado. |
| IStateManager.IsTrackingViewState |
Obtém um valor que indica se a coleção StateManagedCollection está salvando alterações no estado de exibição. |
| IStateManager.LoadViewState(Object) |
Restaura o estado de exibição salvo anteriormente da coleção StateManagedCollection e o itens IStateManager que ele contém. |
| IStateManager.SaveViewState() |
Salva as alterações na coleção StateManagedCollection e cada objeto IStateManager que ela contém, desde o momento em que a página foi postada novamente no servidor. |
| IStateManager.TrackViewState() |
Faz com que a coleção StateManagedCollection e os objetos IStateManager que ela contém controlem as alterações realizadas no estado de exibição, para que elas possam ser mantidas em todas as solicitações para a mesma página. |
Métodos de Extensão
| Cast<TResult>(IEnumerable) |
Converte os elementos de um IEnumerable para o tipo especificado. |
| OfType<TResult>(IEnumerable) |
Filtra os elementos de um IEnumerable com base em um tipo especificado. |
| AsParallel(IEnumerable) |
Habilita a paralelização de uma consulta. |
| AsQueryable(IEnumerable) |
Converte um IEnumerable em um IQueryable. |