Udostępnij za pośrednictwem


StateManagedCollection Klasa

Definicja

Udostępnia klasę bazową dla wszystkich silnie typiowanych kolekcji, które zarządzają obiektami IStateManager .

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
Dziedziczenie
StateManagedCollection
Pochodne
Implementuje

Przykłady

W poniższym przykładzie kodu pokazano, jak utworzyć silnie typizowana klasę kolekcji z StateManagedCollection , aby zawierać IStateManager obiekty. W tym przykładzie element jest tworzony w taki sposób, CycleCollection aby zawierał wystąpienia klasy abstrakcyjnej Cycle , które mogą być Bicycle obiektami lub albo Tricycle . Klasa Cycle implementuje IStateManager interfejs, ponieważ przechowuje wartość CycleColor właściwości w stanie widoku.

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

Uwagi

Klasa StateManagedCollection jest klasą bazową dla wszystkich silnie typiowanych kolekcji, które przechowują IStateManager elementy, w tym DataControlFieldCollection, ParameterCollection, StyleCollection, TreeNodeBindingCollection, i inne. Kolekcja StateManagedCollection zarządza własnym stanem, a także stanem zawartych w nim elementów. W związku z tym wywołanie w celu IStateManager.SaveViewState zapisania stanu kolekcji i stanu wszystkich elementów znajdujących się obecnie w kolekcji.

Najważniejsze metody, które należy wziąć pod uwagę podczas wyprowadzania z StateManagedCollection klasy to CreateKnownType, GetKnownTypes, OnValidate, SetDirtyi SetDirtyObject. Metody CreateKnownType i GetKnownTypes służą do przechowywania indeksu w stanie widoku dla typu zawartego elementu. Przechowywanie indeksu zamiast w pełni kwalifikowanej nazwy typu zwiększa wydajność. Metoda OnValidate jest wywoływana za każdym razem, gdy elementy kolekcji są manipulowane i weryfikuje elementy zgodnie z regułami biznesowymi. Obecnie implementacja OnValidate metody uniemożliwia null przechowywanie obiektów w kolekcji. Można jednak zastąpić tę metodę, aby zdefiniować własne zachowanie weryfikacji w typie pochodnym. Metoda SetDirty wymusza serializacji całej kolekcji w celu wyświetlenia stanu, a nie tylko serializacji zmian wprowadzonych w stanie od czasu ostatniego załadowania. Metoda SetDirtyObject jest abstrakcyjną metodą, którą można zaimplementować w celu wykonania tego samego zachowania na poziomie elementu.

Ważne

StateManagedCollection przechowuje kwalifikowane przez zestaw nazwy typów elementów kolekcji w stanie widoku. Odwiedzający witrynę może zdekodować stan widoku i pobrać nazwę typu. Jeśli ten scenariusz tworzy problem z zabezpieczeniami w witrynie sieci Web, możesz ręcznie zaszyfrować nazwę typu przed umieszczeniem go w stanie widoku.

Konstruktory

StateManagedCollection()

Inicjuje nowe wystąpienie klasy StateManagedCollection.

Właściwości

Count

Pobiera liczbę elementów zawartych w kolekcji StateManagedCollection .

Metody

Clear()

Usuwa wszystkie elementy z kolekcji StateManagedCollection .

CopyTo(Array, Int32)

Kopiuje elementy StateManagedCollection kolekcji do tablicy, zaczynając od określonego indeksu tablicy.

CreateKnownType(Int32)

Po przesłonięciu w klasie pochodnej tworzy wystąpienie klasy implementujące IStateManagermetodę . Typ utworzonego obiektu jest oparty na określonym elemencie członkowskim kolekcji zwróconej przez metodę GetKnownTypes() .

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetEnumerator()

Zwraca iterator iterujący przez StateManagedCollection kolekcję.

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetKnownTypes()

Po zastąpieniu w klasie pochodnej pobiera tablicę IStateManager typów, które StateManagedCollection może zawierać kolekcja.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
OnClear()

Po zastąpieniu w klasie pochodnej wykonuje dodatkową pracę, zanim Clear() metoda usunie wszystkie elementy z kolekcji.

OnClearComplete()

Po przesłonięciu w klasie pochodnej wykonuje dodatkową pracę po zakończeniu Clear() usuwania wszystkich elementów z kolekcji.

OnInsert(Int32, Object)

Po zastąpieniu klasy pochodnej wykonuje dodatkową pracę przed IList.Insert(Int32, Object) dodaniu elementu do kolekcji przez metodę or IList.Add(Object) .

OnInsertComplete(Int32, Object)

Po zastąpieniu w klasie pochodnej wykonuje dodatkową pracę po IList.Insert(Int32, Object) dodaniu elementu do kolekcji przez metodę or IList.Add(Object) .

OnRemove(Int32, Object)

Po zastąpieniu w klasie pochodnej wykonuje dodatkową pracę przed IList.Remove(Object) usunięciem określonego elementu z kolekcji przez metodę or IList.RemoveAt(Int32) .

OnRemoveComplete(Int32, Object)

W przypadku zastąpienia w klasie pochodnej wykonuje dodatkową pracę po IList.Remove(Object) usunięciu określonego elementu z kolekcji przez metodę or IList.RemoveAt(Int32) .

OnValidate(Object)

Po przesłonięciu w klasie pochodnej weryfikuje element kolekcji StateManagedCollection .

SetDirty()

Wymusza serializacji całej StateManagedCollection kolekcji w stan widoku.

SetDirtyObject(Object)

Po przesłonięciu w klasie pochodnej instruuje object element zawarty przez kolekcję w celu zarejestrowania całego stanu w celu wyświetlenia stanu, a nie rejestrowania tylko informacji o zmianie.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Jawne implementacje interfejsu

ICollection.Count

Pobiera liczbę elementów zawartych w kolekcji StateManagedCollection .

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy StateManagedCollection kolekcja jest synchronizowana (bezpieczne wątki). Ta metoda zwraca wszystkie false przypadki.

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do StateManagedCollection kolekcji. Ta metoda zwraca wszystkie null przypadki.

IEnumerable.GetEnumerator()

Zwraca iterator iterujący przez StateManagedCollection kolekcję.

IList.Add(Object)

Dodaje element do kolekcji StateManagedCollection .

IList.Clear()

Usuwa wszystkie elementy z kolekcji StateManagedCollection .

IList.Contains(Object)

Określa, czy StateManagedCollection kolekcja zawiera określoną wartość.

IList.IndexOf(Object)

Określa indeks określonego elementu w kolekcji StateManagedCollection .

IList.Insert(Int32, Object)

Wstawia element do kolekcji StateManagedCollection w określonym indeksie.

IList.IsFixedSize

Pobiera wartość wskazującą, czy StateManagedCollection kolekcja ma stały rozmiar. Ta metoda zwraca wszystkie false przypadki.

IList.IsReadOnly

Pobiera wartość wskazującą, czy StateManagedCollection kolekcja jest tylko do odczytu.

IList.Item[Int32]

IStateManager Pobiera element w określonym indeksie.

IList.Remove(Object)

Usuwa pierwsze wystąpienie określonego obiektu z kolekcji StateManagedCollection .

IList.RemoveAt(Int32)

IStateManager Usuwa element w określonym indeksie.

IStateManager.IsTrackingViewState

Pobiera wartość wskazującą, czy StateManagedCollection kolekcja zapisuje zmiany w stanie widoku.

IStateManager.LoadViewState(Object)

Przywraca wcześniej zapisany stan StateManagedCollection widoku kolekcji i IStateManager zawarte w nim elementy.

IStateManager.SaveViewState()

Zapisuje zmiany w StateManagedCollection kolekcji i każdy IStateManager obiekt, który zawiera od czasu opublikowania strony z powrotem na serwerze.

IStateManager.TrackViewState()

Powoduje, że StateManagedCollection kolekcja i każdy z IStateManager obiektów, które zawiera, aby śledzić zmiany w ich stanie wyświetlania, dzięki czemu mogą być utrwalane między żądaniami dla tej samej strony.

Metody rozszerzania

Cast<TResult>(IEnumerable)

Rzutuje elementy elementu IEnumerable na określony typ.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable elementu na podstawie określonego typu.

AsParallel(IEnumerable)

Umożliwia równoległość zapytania.

AsQueryable(IEnumerable)

Konwertuje element IEnumerable na .IQueryable

Dotyczy

Zobacz też