Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/ModelBinding/ModelBinderDictionary.cs

@@ -0,0 +1,157 @@
+namespace System.Web.ModelBinding {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    public class ModelBinderDictionary : IDictionary<Type, IModelBinder> {
+
+        private IModelBinder _defaultBinder;
+        private readonly Dictionary<Type, IModelBinder> _innerDictionary = new Dictionary<Type, IModelBinder>();
+        private ModelBinderProviderCollection _modelBinderProviders;
+
+        public ModelBinderDictionary()
+            : this(ModelBinderProviders.Providers) {
+        }
+
+        internal ModelBinderDictionary(ModelBinderProviderCollection modelBinderProviders) {
+            _modelBinderProviders = modelBinderProviders;
+        }
+
+        public int Count {
+            get {
+                return _innerDictionary.Count;
+            }
+        }
+
+        public IModelBinder DefaultBinder {
+            get {
+                if (_defaultBinder == null) {
+                    _defaultBinder = new DefaultModelBinder();
+                }
+                return _defaultBinder;
+            }
+            set {
+                _defaultBinder = value;
+            }
+        }
+
+        public bool IsReadOnly {
+            get {
+                return ((IDictionary<Type, IModelBinder>)_innerDictionary).IsReadOnly;
+            }
+        }
+
+        public ICollection<Type> Keys {
+            get {
+                return _innerDictionary.Keys;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_innerDictionary", Justification = "Chances of using model binders for com interop types is pretty low.")]
+        public IModelBinder this[Type key]
+        {
+            get {
+
+                IModelBinder binder;
+                _innerDictionary.TryGetValue(key, out binder);
+                return binder;
+            }
+            set {
+                _innerDictionary[key] = value;
+            }
+        }
+
+        public ICollection<IModelBinder> Values {
+            get {
+                return _innerDictionary.Values;
+            }
+        }
+
+        public void Add(KeyValuePair<Type, IModelBinder> item) {
+            ((IDictionary<Type, IModelBinder>)_innerDictionary).Add(item);
+        }
+
+        [SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_innerDictionary", Justification = "Chances of using model binders for com interop types is pretty low.")]
+        public void Add(Type key, IModelBinder value)
+        {
+            _innerDictionary.Add(key, value);
+        }
+
+        public void Clear() {
+            _innerDictionary.Clear();
+        }
+
+        public bool Contains(KeyValuePair<Type, IModelBinder> item) {
+            return ((IDictionary<Type, IModelBinder>)_innerDictionary).Contains(item);
+        }
+
+        public bool ContainsKey(Type key) {
+            return _innerDictionary.ContainsKey(key);
+        }
+
+        public void CopyTo(KeyValuePair<Type, IModelBinder>[] array, int arrayIndex) {
+            ((IDictionary<Type, IModelBinder>)_innerDictionary).CopyTo(array, arrayIndex);
+        }
+
+#if UNDEF
+        public IModelBinder GetBinder(Type modelType) {
+            return GetBinder(modelType, true /* fallbackToDefault */);
+        }
+
+        public virtual IModelBinder GetBinder(Type modelType, bool fallbackToDefault) {
+            if (modelType == null) {
+                throw new ArgumentNullException("modelType");
+            }
+
+            return GetBinder(modelType, (fallbackToDefault) ? DefaultBinder : null);
+        }
+
+        private IModelBinder GetBinder(Type modelType, IModelBinder fallbackBinder) {
+
+            // Try to look up a binder for this type. We use this order of precedence:
+            // 1. Binder returned from provider
+            // 2. Binder registered in the global table
+            // 3. Binder attribute defined on the type
+            // 4. Supplied fallback binder
+
+            IModelBinder binder = _modelBinderProviders.GetBinder(modelType);
+            if (binder != null) {
+                return binder;
+            }
+
+            if (_innerDictionary.TryGetValue(modelType, out binder)) {
+                return binder;
+            }
+
+            binder = ModelBinders.GetBinderFromAttributes(modelType,
+                () => String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.ModelBinderDictionary_MultipleAttributes), modelType.FullName));
+
+            return binder ?? fallbackBinder;
+        }
+#endif
+
+        public IEnumerator<KeyValuePair<Type, IModelBinder>> GetEnumerator() {
+            return _innerDictionary.GetEnumerator();
+        }
+
+        public bool Remove(KeyValuePair<Type, IModelBinder> item) {
+            return ((IDictionary<Type, IModelBinder>)_innerDictionary).Remove(item);
+        }
+
+        public bool Remove(Type key) {
+            return _innerDictionary.Remove(key);
+        }
+
+        public bool TryGetValue(Type key, out IModelBinder value) {
+            return _innerDictionary.TryGetValue(key, out value);
+        }
+
+        #region IEnumerable Members
+        IEnumerator IEnumerable.GetEnumerator() {
+            return ((IEnumerable)_innerDictionary).GetEnumerator();
+        }
+        #endregion
+
+    }
+}