Files
mono/mcs/class/referencesource/System.Web/UI/StateManagedCollection.cs
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

743 lines
22 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="StateManagedCollection.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing.Design;
using System.Reflection;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Util;
/// <devdoc>
/// Manages state for an arbitrary collection of items that implement IStateManager.
/// The collection differentiates between known types and unknown types.
/// Known types take up less space in ViewState because only an index needs to be stored instead of a fully qualified type name.
/// Unknown types need to have their fully qualified type name stored in ViewState so they take up more space.
/// </devdoc>
public abstract class StateManagedCollection : IList, IStateManager {
private ArrayList _collectionItems;
private bool _tracking;
private bool _saveAll;
// We want to know if the collection had items to begin with
// so we don't put empty collections in the ViewState unnecessarily
private bool _hadItems;
/// <devdoc>
/// Creates a new instance of StateManagedCollection.
/// </devdoc>
protected StateManagedCollection() {
_collectionItems = new ArrayList();
}
/// <devdoc>
/// Returns the number of items in the collection.
/// </devdoc>
public int Count {
get {
return _collectionItems.Count;
}
}
/// <devdoc>
/// Removes all the items from the collection.
/// </devdoc>
public void Clear() {
OnClear();
_collectionItems.Clear();
OnClearComplete();
if (_tracking) {
_saveAll = true;
}
}
public void CopyTo(Array array, int index) {
_collectionItems.CopyTo(array, index);
}
/// <devdoc>
/// Creates an object of a known type based on an index into an array of types.
/// Indexes passed into CreateKnownType() must mach the indexes of the ArrayList returned
/// by GetKnownTypes().
/// </devdoc>
protected virtual object CreateKnownType(int index) {
throw new InvalidOperationException(SR.GetString(SR.StateManagedCollection_NoKnownTypes));
}
/// <devdoc>
/// Returns the IEnumerator for the collection.
/// </devdoc>
public IEnumerator GetEnumerator() {
return _collectionItems.GetEnumerator();
}
/// <devdoc>
/// Returns an ordered list of known types.
/// </devdoc>
protected virtual Type[] GetKnownTypes() {
return null;
}
/// <devdoc>
/// Returns the number of known types.
/// </devdoc>
private int GetKnownTypeCount() {
Type[] types = GetKnownTypes();
if (types == null)
return 0;
return types.Length;
}
/// <devdoc>
/// Inserts a new object into the collection at a given index.
/// If the index is -1 then the object is appended to the end of the collection.
/// </devdoc>
private void InsertInternal(int index, object o) {
Debug.Assert(index >= -1 && index <= Count, "Expected index to be at least -1 and less than or equal to Count.");
if (o == null) {
throw new ArgumentNullException("o");
}
if (((IStateManager)this).IsTrackingViewState) {
((IStateManager)o).TrackViewState();
SetDirtyObject(o);
}
OnInsert(index, o);
int trueIndex;
if (index == -1) {
trueIndex = _collectionItems.Add(o);
}
else {
trueIndex = index;
_collectionItems.Insert(index, o);
}
try {
OnInsertComplete(index, o);
}
catch {
_collectionItems.RemoveAt(trueIndex);
throw;
}
}
/// <devdoc>
/// Loads all items from view state.
/// </devdoc>
private void LoadAllItemsFromViewState(object savedState) {
Debug.Assert(savedState != null);
Debug.Assert(savedState is Pair);
Pair p1 = (Pair)savedState;
if (p1.Second is Pair) {
Pair p2 = (Pair)p1.Second;
// save all mode; some objects are typed
object[] states = (object[])p1.First;
int[] typeIndices = (int[])p2.First;
ArrayList typedObjectTypeNames = (ArrayList)p2.Second;
Clear();
for (int i = 0; i < states.Length; i++) {
object o;
// If there is only one known type, we don't need type indices
if (typeIndices == null) {
// Create known type
o = CreateKnownType(0);
}
else {
int typeIndex = typeIndices[i];
if (typeIndex < GetKnownTypeCount()) {
// Create known type
o = CreateKnownType(typeIndex);
}
else {
string typeName = (string)typedObjectTypeNames[typeIndex - GetKnownTypeCount()];
Type type = Type.GetType(typeName);
o = Activator.CreateInstance(type);
}
}
((IStateManager)o).TrackViewState();
((IStateManager)o).LoadViewState(states[i]);
((IList)this).Add(o);
}
}
else {
Debug.Assert(p1.First is object[]);
// save all mode; all objects are instances of known types
object[] states = (object[])p1.First;
int[] typeIndices = (int[])p1.Second;
Clear();
for (int i = 0; i < states.Length; i++) {
// Create known type
int typeIndex = 0;
if (typeIndices != null) {
typeIndex = (int)typeIndices[i];
}
object o = CreateKnownType(typeIndex);
((IStateManager)o).TrackViewState();
((IStateManager)o).LoadViewState(states[i]);
((IList)this).Add(o);
}
}
}
/// <devdoc>
/// Loads only changed items from view state.
/// </devdoc>
private void LoadChangedItemsFromViewState(object savedState) {
Debug.Assert(savedState != null);
Debug.Assert(savedState is Triplet);
Triplet t = (Triplet)savedState;
if (t.Third is Pair) {
// save some mode; some new objects are typed
Pair p = (Pair)t.Third;
ArrayList indices = (ArrayList)t.First;
ArrayList states = (ArrayList)t.Second;
ArrayList typeIndices = (ArrayList)p.First;
ArrayList typedObjectTypeNames = (ArrayList)p.Second;
for (int i = 0; i < indices.Count; i++) {
int index = (int)indices[i];
if (index < Count) {
((IStateManager)((IList)this)[index]).LoadViewState(states[i]);
}
else {
object o;
// If there is only one known type, we don't need type indices
if (typeIndices == null) {
// Create known type
o = CreateKnownType(0);
}
else {
int typeIndex = (int)typeIndices[i];
if (typeIndex < GetKnownTypeCount()) {
// Create known type
o = CreateKnownType(typeIndex);
}
else {
string typeName = (string)typedObjectTypeNames[typeIndex - GetKnownTypeCount()];
Type type = Type.GetType(typeName);
o = Activator.CreateInstance(type);
}
}
((IStateManager)o).TrackViewState();
((IStateManager)o).LoadViewState(states[i]);
((IList)this).Add(o);
}
}
}
else {
// save some mode; all new objects are instances of known types
ArrayList indices = (ArrayList)t.First;
ArrayList states = (ArrayList)t.Second;
ArrayList typeIndices = (ArrayList)t.Third;
for (int i = 0; i < indices.Count; i++) {
int index = (int)indices[i];
if (index < Count) {
((IStateManager)((IList)this)[index]).LoadViewState(states[i]);
}
else {
// Create known type
int typeIndex = 0;
if (typeIndices != null) {
typeIndex = (int)typeIndices[i];
}
object o = CreateKnownType(typeIndex);
((IStateManager)o).TrackViewState();
((IStateManager)o).LoadViewState(states[i]);
((IList)this).Add(o);
}
}
}
}
/// <devdoc>
/// Called when the Clear() method is starting.
/// </devdoc>
protected virtual void OnClear() {
}
/// <devdoc>
/// Called when the Clear() method is complete.
/// </devdoc>
protected virtual void OnClearComplete() {
}
/// <devdoc>
/// Called when an object must be validated.
/// </devdoc>
protected virtual void OnValidate(object value) {
if (value == null) throw new ArgumentNullException("value");
}
/// <devdoc>
/// Called when the Insert() method is starting.
/// </devdoc>
protected virtual void OnInsert(int index, object value) {
}
/// <devdoc>
/// Called when the Insert() method is complete.
/// </devdoc>
protected virtual void OnInsertComplete(int index, object value) {
}
/// <devdoc>
/// Called when the Remove() method is starting.
/// </devdoc>
protected virtual void OnRemove(int index, object value) {
}
/// <devdoc>
/// Called when the Remove() method is complete.
/// </devdoc>
protected virtual void OnRemoveComplete(int index, object value) {
}
/// <devdoc>
/// Saves all items in the collection to view state.
/// </devdoc>
private object SaveAllItemsToViewState() {
Debug.Assert(_saveAll);
bool hasState = false;
int count = _collectionItems.Count;
int[] typeIndices = new int[count];
object[] states = new object[count];
ArrayList typedObjectTypeNames = null;
IDictionary typedObjectTracker = null;
int knownTypeCount = GetKnownTypeCount();
for (int i = 0; i < count; i++) {
object o = _collectionItems[i];
SetDirtyObject(o);
states[i] = ((IStateManager)o).SaveViewState();
if (states[i] != null)
hasState = true;
Type objectType = o.GetType();
int knownTypeIndex = -1;
// If there are known types, find index
if (knownTypeCount != 0) {
knownTypeIndex = ((IList)GetKnownTypes()).IndexOf(objectType);
}
if (knownTypeIndex != -1) {
// Type is known
typeIndices[i] = knownTypeIndex;
}
else {
// Type is unknown
if (typedObjectTypeNames == null) {
typedObjectTypeNames = new ArrayList();
typedObjectTracker = new HybridDictionary();
}
// Get index of type
object index = typedObjectTracker[objectType];
// If type is not in list, add it to the list
if (index == null) {
typedObjectTypeNames.Add(objectType.AssemblyQualifiedName);
// Offset the index by the known type count
index = typedObjectTypeNames.Count + knownTypeCount - 1;
typedObjectTracker[objectType] = index;
}
typeIndices[i] = (int)index;
}
}
// If the collection didn't have items to begin with don't save the state
if (!_hadItems && !hasState) {
return null;
}
if (typedObjectTypeNames == null) {
// all objects are instances known types
// If there is only one known type, then all objects are of that type so the indices are not needed
if (knownTypeCount == 1)
typeIndices = null;
return new Pair(states, typeIndices);
}
else {
return new Pair(states, new Pair(typeIndices, typedObjectTypeNames));
}
}
/// <devdoc>
/// Saves changed items to view state.
/// </devdoc>
private object SaveChangedItemsToViewState() {
Debug.Assert(_saveAll == false);
bool hasState = false;
int count = _collectionItems.Count;
ArrayList indices = new ArrayList();
ArrayList states = new ArrayList();
ArrayList typeIndices = new ArrayList();
ArrayList typedObjectTypeNames = null;
IDictionary typedObjectTracker = null;
int knownTypeCount = GetKnownTypeCount();
for (int i = 0; i < count; i++) {
object o = _collectionItems[i];
object state = ((IStateManager)o).SaveViewState();
if (state != null) {
hasState = true;
indices.Add(i);
states.Add(state);
Type objectType = o.GetType();
int knownTypeIndex = -1;
// If there are known types, find index
if (knownTypeCount != 0) {
knownTypeIndex = ((IList)GetKnownTypes()).IndexOf(objectType);
}
if (knownTypeIndex != -1) {
// Type is known
typeIndices.Add(knownTypeIndex);
}
else {
// Type is unknown
if (typedObjectTypeNames == null) {
typedObjectTypeNames = new ArrayList();
typedObjectTracker = new HybridDictionary();
}
object index = typedObjectTracker[objectType];
if (index == null) {
typedObjectTypeNames.Add(objectType.AssemblyQualifiedName);
// Offset the index by the known type count
index = typedObjectTypeNames.Count + knownTypeCount - 1;
typedObjectTracker[objectType] = index;
}
typeIndices.Add(index);
}
}
}
// If the collection didn't have items to begin with don't save the state
if (!_hadItems && !hasState) {
return null;
}
if (typedObjectTypeNames == null) {
// all objects are instances known types
// If there is only one known type, then all objects are of that type so the indices are not needed
if (knownTypeCount == 1)
typeIndices = null;
return new Triplet(indices, states, typeIndices);
}
else {
return new Triplet(indices, states, new Pair(typeIndices, typedObjectTypeNames));
}
}
/// <devdoc>
/// Forces the entire collection to be serialized into viewstate, not just
/// the change-information. This is useful when a collection has changed in
/// a significant way and change information would be insufficient to
/// recreate the object.
/// </devdoc>
public void SetDirty() {
_saveAll = true;
}
/// <devdoc>
/// Flags an object to record its entire state instead of just changed parts.
/// </devdoc>
protected abstract void SetDirtyObject(object o);
/// <internalonly/>
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
/// <internalonly/>
int ICollection.Count {
get {
return Count;
}
}
/// <internalonly/>
bool ICollection.IsSynchronized {
get {
return false;
}
}
/// <internalonly/>
object ICollection.SyncRoot {
get {
return null;
}
}
/// <internalonly/>
bool IList.IsFixedSize {
get {
return false;
}
}
/// <internalonly/>
bool IList.IsReadOnly {
get {
return _collectionItems.IsReadOnly;
}
}
/// <internalonly/>
object IList.this[int index] {
get {
return _collectionItems[index];
}
set {
if (index < 0 || index >= Count) {
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.StateManagedCollection_InvalidIndex));
}
((IList)this).RemoveAt(index);
((IList)this).Insert(index, value);
}
}
/// <internalonly/>
int IList.Add(object value) {
OnValidate(value);
InsertInternal(-1, value);
return _collectionItems.Count - 1;
}
/// <internalonly/>
void IList.Clear() {
Clear();
}
/// <internalonly/>
bool IList.Contains(object value) {
if (value == null) {
return false;
}
OnValidate(value);
return _collectionItems.Contains(value);
}
/// <internalonly/>
int IList.IndexOf(object value) {
if (value == null) {
return -1;
}
OnValidate(value);
return _collectionItems.IndexOf(value);
}
/// <internalonly/>
void IList.Insert(int index, object value) {
if (value == null) {
throw new ArgumentNullException("value");
}
if (index < 0 || index > Count) {
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.StateManagedCollection_InvalidIndex));
}
OnValidate(value);
InsertInternal(index, value);
if (_tracking) {
_saveAll = true;
}
}
/// <internalonly/>
void IList.Remove(object value) {
if (value == null) {
return;
}
OnValidate(value);
((IList)this).RemoveAt(((IList)this).IndexOf(value));
}
/// <internalonly/>
void IList.RemoveAt(int index) {
object o = _collectionItems[index];
OnRemove(index, o);
_collectionItems.RemoveAt(index);
try {
OnRemoveComplete(index, o);
}
catch {
_collectionItems.Insert(index, o);
throw;
}
if (_tracking) {
_saveAll = true;
}
}
/// <internalonly/>
bool IStateManager.IsTrackingViewState {
get {
return _tracking;
}
}
/// <internalonly/>
void IStateManager.LoadViewState(object savedState) {
if (savedState != null) {
if (savedState is Triplet) {
LoadChangedItemsFromViewState(savedState);
}
else {
LoadAllItemsFromViewState(savedState);
}
}
}
/// <internalonly/>
object IStateManager.SaveViewState() {
if (_saveAll) {
return SaveAllItemsToViewState();
}
else {
return SaveChangedItemsToViewState();
}
}
/// <internalonly/>
void IStateManager.TrackViewState() {
if (!((IStateManager)this).IsTrackingViewState) {
_hadItems = Count > 0;
_tracking = true;
foreach (IStateManager o in _collectionItems) {
o.TrackViewState();
}
}
}
}
}