Exporter (0) Imprimer
Développer tout

StateManagedCollection, classe

Remarque : cette classe est nouvelle dans le .NET Framework version 2.0.

Fournit une classe de base pour toutes les collections fortement typées qui gèrent des objets IStateManager.

Espace de noms : System.Web.UI
Assembly : System.Web (dans system.web.dll)

public abstract class StateManagedCollection : IList, ICollection, IEnumerable, 
	IStateManager
public abstract class StateManagedCollection implements IList, ICollection, 
	IEnumerable, IStateManager
public abstract class StateManagedCollection implements IList, ICollection, 
	IEnumerable, IStateManager

La classe StateManagedCollection constitue la classe de base pour toutes les collections fortement typées qui stockent des éléments IStateManager, notamment DataControlFieldCollection, ParameterCollection, StyleCollection et TreeNodeBindingCollection. La collection StateManagedCollection gère son propre état ainsi que l'état des éléments qu'elle contient. Par conséquent, un appel à System.Web.UI.IStateManager.SaveViewState enregistre l'état de la collection et l'état de tous les éléments qu'elle contient actuellement.

Les méthodes les plus importantes à envisager dans le cas d'une dérivation de la classe StateManagedCollection sont CreateKnownType, GetKnownTypes, OnValidate, SetDirty et SetDirtyObject. Les méthodes CreateKnownType et GetKnownTypes sont utilisées pour stocker un index dans l'état d'affichage du type d'un élément contenu. Stocker un index plutôt qu'un nom de type qualifié complet améliore les performances. La méthode OnValidate est appelée à chaque fois que les éléments de la collection sont manipulés, et valide les éléments selon des règles métier. Actuellement, l'implémentation de la méthode OnValidate interdit le stockage d'objets référence Null (Nothing en Visual Basic) dans la collection ; toutefois, vous pouvez substituer cette méthode pour définir votre propre comportement de validation dans un type dérivé. La méthode SetDirty force la sérialisation de l'intégralité de la collection dans l'état d'affichage, plutôt que la seule sérialisation des modifications apportées à l'état depuis le dernier chargement. SetDirtyObject est une méthode abstraite que vous pouvez implémenter pour exécuter ce même comportement au niveau de l'élément.

AttentionAttention

StateManagedCollection stocke les noms de types qualifiés d'assembly des éléments de collection dans l'état d'affichage. Un visiteur du site peut décoder l'état d'affichage et récupérer le nom de type. Si ce scénario crée un problème de sécurité dans votre site Web, vous pouvez chiffrer manuellement le nom de type avant de le placer dans l'état d'affichage.

L'exemple de code suivant montre comment dériver une classe de collection fortement typée de StateManagedCollection pour contenir des objets IStateManager. Dans cet exemple, le CycleCollection est dérivé pour contenir des instances de la classe abstraite Cycle, qui peuvent consister en des objets Bicycle ou Tricycle. La classe Cycle implémente l'interface IStateManager, car elle stocke la valeur de la propriété CycleColor dans l'état 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) {}
    }

}

System.Object
  System.Web.UI.StateManagedCollection
     Classes dérivées

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft