StateManagedCollection Klasse

Definition

Namespace:

System.Web.UI

Assembly:

System.Web.dll

Stellt eine Basisklasse für alle stark typisierten Auflistungen bereit, die IStateManager-Objekte verwalten.

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

Vererbung

Object

StateManagedCollection

Abgeleitet

System.Web.UI.WebControls.DataControlFieldCollection

System.Web.UI.WebControls.DataPagerFieldCollection

System.Web.UI.WebControls.Expressions.DataSourceExpressionCollection

System.Web.UI.WebControls.HotSpotCollection

System.Web.UI.WebControls.MenuItemBindingCollection

System.Web.UI.WebControls.MenuItemStyleCollection

System.Web.UI.WebControls.ParameterCollection

System.Web.UI.WebControls.StyleCollection

System.Web.UI.WebControls.SubMenuStyleCollection

System.Web.UI.WebControls.TreeNodeBindingCollection

System.Web.UI.WebControls.TreeNodeStyleCollection

Implementiert

ICollection IEnumerable IList IStateManager

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie eine stark eingegebene Auflistungsklasse von Objekten IStateManager abgeleitet StateManagedCollection wird. In diesem Beispiel wird die CycleCollection abgeleitete Instanz der abstrakten Cycle Klasse enthalten, die entweder Bicycle oder Tricycle Objekte sein kann. Die Cycle Klasse implementiert die IStateManager Schnittstelle, da sie den Wert der CycleColor Eigenschaft im Ansichtszustand speichert.

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

Hinweise

Die StateManagedCollection Klasse ist die Basisklasse für alle stark typierten Sammlungen, die Elemente speichernIStateManager, einschließlich DataControlFieldCollection, ParameterCollectionStyleCollectionTreeNodeBindingCollectionund andere. Die StateManagedCollection Auflistung verwaltet ihren eigenen Zustand sowie den Zustand der elemente, die sie enthält. Daher wird ein Aufruf zum IStateManager.SaveViewState Speichern des Zustands der Auflistung und des Zustands aller elemente, die derzeit von der Auflistung enthalten sind, gespeichert.

Die wichtigsten Methoden, die beim Ableiten von der StateManagedCollection Klasse berücksichtigt werden sollen, sind CreateKnownType, , GetKnownTypes, OnValidateSetDirtyund SetDirtyObject. GetKnownTypes Die CreateKnownType Methoden werden verwendet, um einen Index im Ansichtszustand für den Typ eines enthaltenen Elements zu speichern. Das Speichern eines Indexes statt eines vollqualifizierten Typnamens verbessert die Leistung. Die OnValidate Methode wird aufgerufen, wenn Elemente der Auflistung bearbeitet werden, und überprüft die Elemente nach Geschäftsregeln. Derzeit wird die Implementierung der Methode verhindert, dass Objekte in der OnValidate Auflistung gespeichert werden. Sie können diese Methode null jedoch außer Kraft setzen, um ihr eigenes Validierungsverhalten in einem abgeleiteten Typ zu definieren. Die SetDirty Methode erzwingt die gesamte Auflistung, den Zustand anzuzeigen, anstatt nur Änderungen zu serialisieren, die seit dem letzten Laden vorgenommen wurden. Die SetDirtyObject Methode ist eine abstrakte Methode, die Sie implementieren können, um dieses Verhalten auf Elementebene auszuführen.

Wichtig

StateManagedCollection speichert assemblyqualifizierte Typennamen der Auflistungselemente im Ansichtszustand. Ein Websitebesucher könnte den Ansichtsstatus decoden und den Typnamen abrufen. Wenn dieses Szenario ein Sicherheitsproblem auf Ihrer Website erstellt, können Sie den Typnamen manuell verschlüsseln, bevor Sie ihn im Ansichtszustand platzieren.

Konstruktoren

StateManagedCollection()

Initialisiert eine neue Instanz der StateManagedCollection-Klasse.

Eigenschaften

Count

Ruft die Anzahl der Elemente in der StateManagedCollection-Auflistung ab.

Methoden

Clear()	Entfernt alle Elemente aus der StateManagedCollection-Auflistung.
CopyTo(Array, Int32)	Kopiert die Elemente der StateManagedCollection-Auflistung in ein Array, wobei an einem bestimmten Arrayindex begonnen wird.
CreateKnownType(Int32)	Beim Überschreiben in einer abgeleiteten Klasse wird eine Instanz einer Klasse erstellt, die IStateManager implementiert. Der Typ des erstellten Objekts basiert auf dem angegebenen Element der Auflistung, der von der GetKnownTypes()-Methode zurückgegeben wird.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetEnumerator()	Gibt einen Iterator zurück, der die StateManagedCollection-Auflistung durchläuft.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetKnownTypes()	Beim Überschreiben in einer abgeleiteten Klasse wird ein Array von IStateManager-Typen abgerufen, die die StateManagedCollection-Auflistung enthalten kann.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnClear()	Beim Überschreiben in einer abgeleiteten Klasse werden zusätzliche Aufgaben ausgeführt, bevor die Clear()-Methode alle Elemente aus der Auflistung entfernt.
OnClearComplete()	Beim Überschreiben in einer abgeleiteten Klasse werden zusätzliche Aufgaben ausgeführt, nachdem die Clear()-Methode alle Elemente aus der Auflistung entfernt hat.
OnInsert(Int32, Object)	Beim Überschreiben in einer abgeleiteten Klasse werden zusätzliche Aufgaben ausgeführt, bevor die IList.Insert(Int32, Object)-Methode oder die IList.Add(Object)-Methode der Auflistung ein Element hinzufügt.
OnInsertComplete(Int32, Object)	Beim Überschreiben in einer abgeleiteten Klasse werden zusätzliche Aufgaben ausgeführt, nachdem die IList.Insert(Int32, Object)-Methode oder die IList.Add(Object)-Methode der Auflistung ein Element hinzugefügt hat.
OnRemove(Int32, Object)	Beim Überschreiben in einer abgeleiteten Klasse werden zusätzliche Aufgaben ausgeführt, bevor die IList.Remove(Object)-Methode oder die IList.RemoveAt(Int32)-Methode das angegebene Element aus der Auflistung entfernt.
OnRemoveComplete(Int32, Object)	Beim Überschreiben in einer abgeleiteten Klasse werden zusätzliche Aufgaben ausgeführt, nachdem die IList.Remove(Object)-Methode oder die IList.RemoveAt(Int32)-Methode das angegebene Element aus der Auflistung entfernt hat.
OnValidate(Object)	Beim Überschreiben in einer abgeleiteten Klasse wird ein Element der StateManagedCollection-Auflistung validiert.
SetDirty()	Erzwingt den serialisierten Ansichtszustand für die gesamte StateManagedCollection-Auflistung.
SetDirtyObject(Object)	Beim Überschreiben in einer abgeleiteten Klasse wird ein in der Auflistung enthaltenes object angewiesen, seinen gesamten Zustand im Ansichtszustand aufzuzeichnen, anstatt nur die Änderungsinformationen aufzuzeichnen.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

ICollection.Count	Ruft die Anzahl der Elemente in der StateManagedCollection-Auflistung ab.
ICollection.IsSynchronized	Ruft einen Wert ab, der angibt, ob die StateManagedCollection-Auflistung synchronisiert (threadsicher) ist. Diese Methode gibt immer false zurück.
ICollection.SyncRoot	Ruft ein Objekt ab, mit dem der Zugriff auf die StateManagedCollection-Auflistung synchronisiert werden kann. Diese Methode gibt immer null zurück.
IEnumerable.GetEnumerator()	Gibt einen Iterator zurück, der die StateManagedCollection-Auflistung durchläuft.
IList.Add(Object)	Fügt der StateManagedCollection-Auflistung ein Element hinzu.
IList.Clear()	Entfernt alle Elemente aus der StateManagedCollection-Auflistung.
IList.Contains(Object)	Ermittelt, ob die StateManagedCollection-Auflistung einen bestimmten Wert enthält.
IList.IndexOf(Object)	Bestimmt den Index eines bestimmten Elements in der StateManagedCollection-Auflistung.
IList.Insert(Int32, Object)	Fügt ein Element am angegebenen Index in die StateManagedCollection-Auflistung ein.
IList.IsFixedSize	Ruft einen Wert ab, der angibt, ob die StateManagedCollection-Auflistung eine feste Größe aufweist. Diese Methode gibt immer false zurück.
IList.IsReadOnly	Ruft einen Wert ab, der angibt, ob die StateManagedCollection-Auflistung schreibgeschützt ist.
IList.Item[Int32]	Ruft das IStateManager-Element am angegebenen Index ab.
IList.Remove(Object)	Entfernt das erste Vorkommen des angegebenen Objekts aus der StateManagedCollection-Auflistung.
IList.RemoveAt(Int32)	Entfernt das IStateManager-Element am angegebenen Index.
IStateManager.IsTrackingViewState	Ruft einen Wert ab, der angibt, ob die StateManagedCollection-Auflistung Änderungen des Ansichtszustands speichert.
IStateManager.LoadViewState(Object)	Stellt den zuvor gespeicherten Ansichtszustand der StateManagedCollection-Auflistung und der in ihr enthaltenen IStateManager-Elemente wieder her.
IStateManager.SaveViewState()	Speichert die Änderungen an der StateManagedCollection-Auflistung und allen darin enthaltenen IStateManager-Objekten seit dem Zeitpunkt, zu dem die Seite zurück an den Server gesendet wurde.
IStateManager.TrackViewState()	Weist die StateManagedCollection-Auflistung und alle in ihr enthaltenen IStateManager-Objekte an, die Änderungen im Ansichtszustand nachzuverfolgen, sodass diese für die gleiche Seite anforderungsübergreifend beibehalten werden können.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um
OfType<TResult>(IEnumerable)	Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs
AsParallel(IEnumerable)	Ermöglicht die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Konvertiert einen IEnumerable in einen IQueryable.

Siehe auch

• IStateManager
• StateBag