StateManagedCollection Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Fournit une classe de base pour toutes les collections fortement typées qui gèrent des objets 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- Héritage
-
StateManagedCollection
- Dérivé
- Implémente
Exemples
L’exemple de code suivant montre comment dériver une classe de collection fortement typée d’objetsStateManagedCollection.IStateManager Dans cet exemple, il CycleCollection est dérivé pour contenir des instances de la classe abstraite Cycle , qui peuvent être soit Bicycle soit des Tricycle objets. La Cycle classe implémente l’interface IStateManager , car elle stocke la valeur de la propriété dans l’état CycleColor d’affichage.
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
Remarques
La StateManagedCollection classe est la classe de base pour toutes les collections fortement typées qui stockent IStateManager des éléments, notamment DataControlFieldCollection, , ParameterCollection, StyleCollection, TreeNodeBindingCollectionet d’autres. La StateManagedCollection collection gère son propre état ainsi que l’état des éléments qu’il contient. Par conséquent, un appel pour IStateManager.SaveViewState enregistrer l’état de la collection et l’état de tous les éléments actuellement contenus par la collection.
Les méthodes les plus importantes à prendre en compte lors de la dérivation de la StateManagedCollection classe sont CreateKnownType, , GetKnownTypes, OnValidate, SetDirtyet SetDirtyObject. Les méthodes et GetKnownTypes les CreateKnownType méthodes permettent de stocker un index dans l’état d’affichage pour le type d’un élément contenu. Le stockage d’un index plutôt qu’un nom de type complet améliore les performances. La OnValidate méthode est appelée chaque fois que les éléments de la collection sont manipulés et valide les éléments en fonction des règles d’entreprise. Actuellement, l’implémentation de la OnValidate méthode interdit les objets d’être stockés null dans la collection . Toutefois, vous pouvez remplacer cette méthode pour définir votre propre comportement de validation dans un type dérivé. La SetDirty méthode force la sérialisation de l’ensemble de la collection à afficher l’état, au lieu de simplement sérialiser les modifications apportées à l’état depuis la dernière fois qu’elle a été chargée. La SetDirtyObject méthode est une méthode abstraite que vous pouvez implémenter pour effectuer ce même comportement au niveau de l’élément.
Important
StateManagedCollection stocke les noms de type qualifiés d’assembly des éléments de collection dans l’état d’affichage. Un visiteur de site peut décoder l’état d’affichage et récupérer le nom du type. Si ce scénario crée un problème de sécurité dans votre site Web, vous pouvez chiffrer manuellement le nom du type avant de le placer dans l’état d’affichage.
Constructeurs
| StateManagedCollection() |
Initialise une nouvelle instance de la classe StateManagedCollection. |
Propriétés
| Count |
Obtient le nombre d'éléments contenus dans la collection StateManagedCollection. |
Méthodes
| Clear() |
Supprime tous les éléments de la collection StateManagedCollection. |
| CopyTo(Array, Int32) |
Copie les éléments de la collection StateManagedCollection dans un tableau, en commençant au niveau d'un index de tableau particulier. |
| CreateKnownType(Int32) |
En cas de substitution dans une classe dérivée, crée une instance d'une classe qui implémente IStateManager. Le type d'objet créé repose sur le membre spécifié de la collection retournée par la méthode GetKnownTypes(). |
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| GetEnumerator() |
Retourne un itérateur qui itère au sein de la collection StateManagedCollection. |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetKnownTypes() |
En cas de substitution dans une classe dérivée, obtient un tableau de types IStateManager que la collection StateManagedCollection peut contenir. |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| OnClear() |
En cas de substitution dans une classe dérivée, exécute une tâche supplémentaire avant que la méthode Clear() supprime tous les éléments de la collection. |
| OnClearComplete() |
En cas de substitution dans une classe dérivée, exécute une tâche supplémentaire une fois tous les éléments de la collection supprimés par la méthode Clear(). |
| OnInsert(Int32, Object) |
En cas de substitution dans une classe dérivée, exécute une tâche supplémentaire avant que la méthode IList.Insert(Int32, Object) ou IList.Add(Object) ajoute un élément à la collection. |
| OnInsertComplete(Int32, Object) |
En cas de substitution dans une classe dérivée, exécute une tâche supplémentaire après que la méthode IList.Insert(Int32, Object) ou IList.Add(Object) a ajouté un élément à la collection. |
| OnRemove(Int32, Object) |
En cas de substitution dans une classe dérivée, exécute une tâche supplémentaire avant que la méthode IList.Remove(Object) ou IList.RemoveAt(Int32) supprime l'élément spécifié de la collection. |
| OnRemoveComplete(Int32, Object) |
En cas de substitution dans une classe dérivée, exécute une tâche supplémentaire après que la méthode IList.Remove(Object) ou IList.RemoveAt(Int32) a supprimé l'élément spécifié de la collection. |
| OnValidate(Object) |
En cas de substitution dans une classe dérivée, valide un élément de la collection StateManagedCollection. |
| SetDirty() |
Force la sérialisation de l'intégralité de la collection StateManagedCollection dans l'état d'affichage. |
| SetDirtyObject(Object) |
En cas de substitution dans une classe dérivée, commande à un |
| ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
Implémentations d’interfaces explicites
| ICollection.Count |
Obtient le nombre d'éléments contenus dans la collection StateManagedCollection. |
| ICollection.IsSynchronized |
Obtient une valeur indiquant si la collection StateManagedCollection est synchronisée (thread-safe). Cette méthode retourne |
| ICollection.SyncRoot |
Obtient un objet qui peut être utilisé pour synchroniser l'accès à la collection StateManagedCollection. Cette méthode retourne |
| IEnumerable.GetEnumerator() |
Retourne un itérateur qui itère au sein de la collection StateManagedCollection. |
| IList.Add(Object) |
Ajoute un élément à la collection StateManagedCollection. |
| IList.Clear() |
Supprime tous les éléments de la collection StateManagedCollection. |
| IList.Contains(Object) |
Détermine si la collection StateManagedCollection contient une valeur spécifique. |
| IList.IndexOf(Object) |
Détermine l'index d'un élément spécifié de la collection StateManagedCollection. |
| IList.Insert(Int32, Object) |
Insère un élément dans la collection StateManagedCollection au niveau de l'index spécifié. |
| IList.IsFixedSize |
Obtient une valeur indiquant si la collection StateManagedCollection est de taille fixe. Cette méthode retourne |
| IList.IsReadOnly |
Obtient une valeur indiquant si la collection StateManagedCollection est en lecture seule. |
| IList.Item[Int32] |
Obtient l’élément IStateManager à l’index spécifié. |
| IList.Remove(Object) |
Supprime la première occurrence de l'objet spécifié dans la collection StateManagedCollection. |
| IList.RemoveAt(Int32) |
Supprime l'élément IStateManager au niveau de l'index spécifié. |
| IStateManager.IsTrackingViewState |
Obtient une valeur indiquant si la collection StateManagedCollection enregistre les modifications apportées à son état d'affichage. |
| IStateManager.LoadViewState(Object) |
Restaure l'état d'affichage précédemment enregistré de la collection StateManagedCollection et les éléments IStateManager qu'elle contient. |
| IStateManager.SaveViewState() |
Enregistre les modifications apportées à la collection StateManagedCollection et à chaque objet IStateManager qu'elle contient, depuis la publication de la page sur le serveur. |
| IStateManager.TrackViewState() |
Commande à la collection StateManagedCollection et à chacun des objets IStateManager qu'elle contient de procéder au suivi des modifications apportées à leur état d'affichage afin qu'ils puissent être rendus persistants au fil des requêtes d'une même page. |
Méthodes d’extension
| Cast<TResult>(IEnumerable) |
Effectue un cast des éléments d'un IEnumerable vers le type spécifié. |
| OfType<TResult>(IEnumerable) |
Filtre les éléments d'un IEnumerable en fonction du type spécifié. |
| AsParallel(IEnumerable) |
Active la parallélisation d'une requête. |
| AsQueryable(IEnumerable) |
Convertit un IEnumerable en IQueryable. |