Sdílet prostřednictvím


StateManagedCollection Třída

Definice

Poskytuje základní třídu pro všechny kolekce silného typu, které spravují IStateManager objekty.

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
Dědičnost
StateManagedCollection
Odvozené
Implementuje

Příklady

Následující příklad kódu ukazuje, jak odvodit třídu kolekce silného typu z StateManagedCollection toho, aby obsahoval IStateManager objekty. V tomto příkladu CycleCollection je odvozen, aby obsahoval instance abstraktní Cycle třídy, které mohou být buď Bicycle nebo Tricycle objekty. Třída Cycle implementuje IStateManager rozhraní, protože ukládá hodnotu CycleColor vlastnosti ve stavu zobrazení.

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

Poznámky

Třída StateManagedCollection je základní třídou pro všechny kolekce silného typu, které ukládají IStateManager prvky, včetně DataControlFieldCollection, ParameterCollection, , StyleCollectionTreeNodeBindingCollectiona dalších. Kolekce StateManagedCollection spravuje svůj vlastní stav a také stav prvků, které obsahuje. Proto volání, které IStateManager.SaveViewState uloží stav kolekce a stav všech prvků aktuálně obsažených v kolekci.

Nejdůležitějšími metodami, které je třeba vzít v úvahu při odvození z StateManagedCollection třídy, jsou CreateKnownType, GetKnownTypes, OnValidate, SetDirtya SetDirtyObject. Metody CreateKnownType slouží GetKnownTypes k uložení indexu ve stavu zobrazení pro typ obsaženého prvku. Ukládání indexu místo plně kvalifikovaného názvu typu zlepšuje výkon. Metoda OnValidate se volá vždy, když jsou prvky kolekce manipulovány a ověřuje prvky podle obchodních pravidel. V současné době implementace OnValidate metody zakazuje null ukládání objektů v kolekci. Tuto metodu však můžete přepsat tak, aby definovala vlastní chování ověřování v odvozeného typu. Metoda SetDirty vynutí, aby byla celá kolekce serializována k zobrazení stavu, a ne pouze serializace změn provedených ve stavu od posledního načtení. Metoda SetDirtyObject je abstraktní metoda, kterou můžete implementovat pro provedení stejného chování na úrovni elementu.

Důležité

StateManagedCollection ukládá názvy typů kvalifikovaných pro sestavení položek kolekce ve stavu zobrazení. Návštěvník webu může dekódovat stav zobrazení a načíst název typu. Pokud tento scénář na vašem webu vytvoří problém se zabezpečením, můžete název typu před umístěním do stavu zobrazení ručně zašifrovat.

Konstruktory

StateManagedCollection()

Inicializuje novou instanci StateManagedCollection třídy.

Vlastnosti

Count

Získá počet prvků obsažených v kolekci StateManagedCollection .

Metody

Clear()

Odebere všechny položky z StateManagedCollection kolekce.

CopyTo(Array, Int32)

Zkopíruje prvky StateManagedCollection kolekce do pole počínaje konkrétním indexem pole.

CreateKnownType(Int32)

Při přepsání v odvozené třídě vytvoří instanci třídy, která implementuje IStateManager. Typ vytvořeného objektu je založen na zadaném členu kolekce vrácené metodou GetKnownTypes() .

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetEnumerator()

Vrátí iterátor, který prochází kolekcí StateManagedCollection .

GetHashCode()

Slouží jako výchozí funkce hash.

(Zděděno od Object)
GetKnownTypes()

Při přepsání v odvozené třídě získá pole IStateManager typů, které StateManagedCollection kolekce může obsahovat.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
OnClear()

Při přepsání v odvozené třídě provede další práci před Clear() odebráním všech položek z kolekce.

OnClearComplete()

Při přepsání v odvozené třídě provede další práci po Clear() dokončení metody odebrání všech položek z kolekce.

OnInsert(Int32, Object)

Při přepsání v odvozené třídě provede další práci před tím, než IList.Insert(Int32, Object) metoda IList.Add(Object) přidá položku do kolekce.

OnInsertComplete(Int32, Object)

Při přepsání v odvozené třídě provede další práci po IList.Insert(Int32, Object) IList.Add(Object) přidání položky do kolekce.

OnRemove(Int32, Object)

Při přepsání v odvozené třídě provede další práci před IList.Remove(Object) IList.RemoveAt(Int32) odebráním zadané položky z kolekce.

OnRemoveComplete(Int32, Object)

Při přepsání v odvozené třídě provede další práci po IList.Remove(Object) IList.RemoveAt(Int32) odebrání zadané položky z kolekce.

OnValidate(Object)

Při přepsání v odvozené třídě ověří prvek StateManagedCollection kolekce.

SetDirty()

Vynutí, aby se celá StateManagedCollection kolekce serializovala do stavu zobrazení.

SetDirtyObject(Object)

Při přepsání v odvozené třídě dává kolekci pokyn object , aby zaznamenával celý stav, aby zobrazoval stav, a ne zaznamenávat pouze informace o změnách.

ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)

Explicitní implementace rozhraní

ICollection.Count

Získá počet prvků obsažených v kolekci StateManagedCollection .

ICollection.IsSynchronized

Získá hodnotu označující, jestli StateManagedCollection je kolekce synchronizována (bezpečné vlákno). Tato metoda vrátí false ve všech případech.

ICollection.SyncRoot

Získá objekt, který lze použít k synchronizaci přístupu k kolekci StateManagedCollection . Tato metoda vrátí null ve všech případech.

IEnumerable.GetEnumerator()

Vrátí iterátor, který prochází kolekcí StateManagedCollection .

IList.Add(Object)

Přidá položku do StateManagedCollection kolekce.

IList.Clear()

Odebere všechny položky z StateManagedCollection kolekce.

IList.Contains(Object)

Určuje, zda StateManagedCollection kolekce obsahuje konkrétní hodnotu.

IList.IndexOf(Object)

Určuje index zadané položky v kolekci StateManagedCollection .

IList.Insert(Int32, Object)

Vloží položku do StateManagedCollection kolekce v zadaném indexu.

IList.IsFixedSize

Získá hodnotu určující, zda StateManagedCollection kolekce má pevnou velikost. Tato metoda vrátí ve false všech případech.

IList.IsReadOnly

Získá hodnotu označující, zda StateManagedCollection je kolekce jen pro čtení.

IList.Item[Int32]

IStateManager Získá prvek v zadaném indexu.

IList.Remove(Object)

Odebere první výskyt zadaného objektu StateManagedCollection z kolekce.

IList.RemoveAt(Int32)

Odebere IStateManager prvek v zadaném indexu.

IStateManager.IsTrackingViewState

Získá hodnotu určující, zda StateManagedCollection kolekce ukládá změny do stavu zobrazení.

IStateManager.LoadViewState(Object)

Obnoví dříve uložený stav StateManagedCollection zobrazení kolekce a IStateManager položky, které obsahuje.

IStateManager.SaveViewState()

Uloží změny StateManagedCollection kolekce a každý IStateManager objekt, který obsahuje od doby, kdy byla stránka publikována zpět na server.

IStateManager.TrackViewState()

StateManagedCollection Způsobí, že kolekce a každý z IStateManager objektů, které obsahuje, budou sledovat změny jejich stavu zobrazení, aby je bylo možné uchovávat napříč požadavky na stejnou stránku.

Metody rozšíření

Cast<TResult>(IEnumerable)

Přetypuje prvky zadaného IEnumerable typu.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.

AsParallel(IEnumerable)

Umožňuje paralelizaci dotazu.

AsQueryable(IEnumerable)

Převede na IEnumerable IQueryable.

Platí pro

Viz také