Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebControls/MethodParametersDictionary.cs

@@ -0,0 +1,215 @@
+namespace System.Web.UI.WebControls {
+    
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+
+    internal sealed class MethodParametersDictionary : IDictionary<string, MethodParameterValue>, IStateManager {
+
+        private bool _tracking;
+        private EventHandler _parametersChangedHandler;
+        private Dictionary<string, MethodParameterValue> _innerDictionary;
+
+        /// <devdoc>
+        /// Used by Parameters to raise the ParametersChanged event.
+        /// </devdoc>
+        internal void CallOnParametersChanged() {
+            OnParametersChanged(EventArgs.Empty);
+        }
+
+        /// <devdoc>
+        /// Raises the ParametersChanged event.
+        /// </devdoc>
+        private void OnParametersChanged(EventArgs e) {
+            if (_parametersChangedHandler != null) {
+                _parametersChangedHandler(this, e);
+            }
+        }
+
+        /// <devdoc>
+        /// Occurs when any of the Parameter Values in the dictionary change.
+        /// </devdoc>
+        public event EventHandler ParametersChanged {
+            add {
+                _parametersChangedHandler = (EventHandler)Delegate.Combine(_parametersChangedHandler, value);
+            }
+            remove {
+                _parametersChangedHandler = (EventHandler)Delegate.Remove(_parametersChangedHandler, value);
+            }
+        }
+
+        public int Count {
+            get {
+                return InnerDictionary.Count;
+            }
+        }
+
+        private void LoadViewState(object savedState) {
+            if (savedState != null) {
+                Debug.Assert(savedState is Pair);
+                Pair pair = (Pair)savedState;
+
+                string[] names = (string[])pair.First;
+                object[] states = (object[])pair.Second;
+
+                for (int i = 0; i < names.Length; i++) {
+                    string key = names[i];
+                    Debug.Assert(!InnerDictionary.ContainsKey(key), "The collection was not empty when loading the viewstate");
+                    MethodParameterValue parameter = new MethodParameterValue();
+                    Add(key, parameter);
+                    ((IStateManager)parameter).LoadViewState(states[i]);
+                }
+            }
+        }
+
+        private object SaveViewState() {
+            bool hasState = false;
+            int count = Count;
+            string[] names = new string[count];
+            object[] states = new object[count];
+
+            int i = 0;
+            foreach (KeyValuePair<string, MethodParameterValue> kvp in InnerDictionary) {
+                names[i] = kvp.Key;
+                states[i] = ((IStateManager)kvp.Value).SaveViewState();
+                if (states[i] != null)
+                    hasState = true;
+                i++;
+            }
+
+            return hasState ? new Pair(names, states) : null;
+        }
+
+        private void TrackViewState() {
+            _tracking = true;
+            foreach (MethodParameterValue parameter in InnerDictionary.Values) {
+                ((IStateManager)parameter).TrackViewState();
+            }
+        }
+
+        private Dictionary<string, MethodParameterValue> InnerDictionary {
+            get {
+                if (_innerDictionary == null) {
+                    _innerDictionary = new Dictionary<string, MethodParameterValue>();
+                }
+                return _innerDictionary;
+            }
+        }
+
+        #region IDictionary<KeyValuePair<string,MethodParameter>> Members
+        public ICollection<string> Keys {
+            get {
+                return InnerDictionary.Keys;
+            }
+        }
+
+        public ICollection<MethodParameterValue> Values {
+            get {
+                return InnerDictionary.Values;
+            }
+        }
+
+        public MethodParameterValue this[string key] {
+            get {
+                return InnerDictionary[key];
+            }
+            set {
+                InnerDictionary[key] = value;
+                if (value != null) {
+                    value.SetOwner(this);
+                }
+            }
+        }
+
+        public void Add(string key, MethodParameterValue value) {
+            InnerDictionary.Add(key, value);
+            if (value != null) {
+                value.SetOwner(this);
+                if (_tracking) {
+                    ((IStateManager)value).TrackViewState();
+                }
+            }
+        }
+
+        public bool ContainsKey(string key) {
+            return InnerDictionary.ContainsKey(key);
+        }
+
+        public bool Remove(string key) {
+            if (InnerDictionary.ContainsKey(key)) {
+                MethodParameterValue value = InnerDictionary[key];
+                if (value != null) {
+                    value.SetOwner(null);
+                }
+            }
+            return InnerDictionary.Remove(key);
+        }
+
+        public bool TryGetValue(string key, out MethodParameterValue value) {
+            return InnerDictionary.TryGetValue(key, out value);
+        }
+        #endregion
+
+        #region ICollection<KeyValuePair<string,MethodParameter>> Members
+        void ICollection<KeyValuePair<string, MethodParameterValue>>.Clear() {
+            InnerDictionary.Clear();
+        }
+
+        bool ICollection<KeyValuePair<string, MethodParameterValue>>.IsReadOnly {
+            get {
+                return ((ICollection<KeyValuePair<string, MethodParameterValue>>)InnerDictionary).IsReadOnly;
+            }
+        }
+
+        void ICollection<KeyValuePair<string, MethodParameterValue>>.Add(KeyValuePair<string, MethodParameterValue> item) {
+            Add(item.Key, item.Value);
+        }
+
+        bool ICollection<KeyValuePair<string, MethodParameterValue>>.Contains(KeyValuePair<string, MethodParameterValue> item) {
+            return ((ICollection<KeyValuePair<string, MethodParameterValue>>)InnerDictionary).Contains(item);
+        }
+
+        void ICollection<KeyValuePair<string, MethodParameterValue>>.CopyTo(KeyValuePair<string, MethodParameterValue>[] array, int arrayIndex) {
+            ((ICollection<KeyValuePair<string, MethodParameterValue>>)InnerDictionary).CopyTo(array, arrayIndex);
+        }
+
+        bool ICollection<KeyValuePair<string, MethodParameterValue>>.Remove(KeyValuePair<string, MethodParameterValue> item) {
+            return ((ICollection<KeyValuePair<string, MethodParameterValue>>)InnerDictionary).Remove(item);
+        }
+        #endregion
+
+        #region IEnumerable<KeyValuePair<string,MethodParameter>> Members
+        public IEnumerator<KeyValuePair<string, MethodParameterValue>> GetEnumerator() {
+            return InnerDictionary.GetEnumerator();
+        }
+        #endregion
+
+        #region IEnumerable Members
+        IEnumerator IEnumerable.GetEnumerator() {
+            return GetEnumerator();
+        }
+        #endregion
+
+        #region Implementation of IStateManager
+
+        bool IStateManager.IsTrackingViewState {
+            get {
+                return _tracking;
+            }
+        }
+
+        void IStateManager.LoadViewState(object savedState) {
+            LoadViewState(savedState);
+        }
+
+        object IStateManager.SaveViewState() {
+            return SaveViewState();
+        }
+
+        void IStateManager.TrackViewState() {
+            TrackViewState();
+        }
+        #endregion
+    }
+}