Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,109 @@
+namespace System.Web.ModelBinding {
+    using System;
+    using System.Collections;
+    using System.Globalization;
+    using System.Linq;
+
+    internal static class ModelBinderUtil {
+
+        public static TModel CastOrDefault<TModel>(object model) {
+            return (model is TModel) ? (TModel)model : default(TModel);
+        }
+
+        public static string CreateIndexModelName(string parentName, int index) {
+            return CreateIndexModelName(parentName, index.ToString(CultureInfo.InvariantCulture));
+        }
+
+        public static string CreateIndexModelName(string parentName, string index) {
+            return (parentName.Length == 0) ? "[" + index + "]" : parentName + "[" + index + "]";
+        }
+
+        public static string CreatePropertyModelName(string prefix, string propertyName) {
+            if (String.IsNullOrEmpty(prefix)) {
+                return propertyName ?? String.Empty;
+            }
+            else if (String.IsNullOrEmpty(propertyName)) {
+                return prefix ?? String.Empty;
+            }
+            else {
+                return prefix + "." + propertyName;
+            }
+        }
+
+        public static IModelBinder GetPossibleBinderInstance(Type closedModelType, Type openModelType, Type openBinderType) {
+            Type[] typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(closedModelType, openModelType);
+            return (typeArguments != null) ? (IModelBinder)Activator.CreateInstance(openBinderType.MakeGenericType(typeArguments)) : null;
+        }
+
+        public static object[] RawValueToObjectArray(object rawValue) {
+            // precondition: rawValue is not null
+
+            // Need to special-case String so it's not caught by the IEnumerable check which follows
+            if (rawValue is string) {
+                return new object[] { rawValue };
+            }
+
+            object[] rawValueAsObjectArray = rawValue as object[];
+            if (rawValueAsObjectArray != null) {
+                return rawValueAsObjectArray;
+            }
+
+            IEnumerable rawValueAsEnumerable = rawValue as IEnumerable;
+            if (rawValueAsEnumerable != null) {
+                return rawValueAsEnumerable.Cast<object>().ToArray();
+            }
+
+            // fallback
+            return new object[] { rawValue };
+        }
+
+        public static void ReplaceEmptyStringWithNull(ModelMetadata modelMetadata, ref object model) {
+            if (modelMetadata.ConvertEmptyStringToNull && StringIsEmptyOrWhitespace(model as string)) {
+                model = null;
+            }
+        }
+
+        // Based on String.IsNullOrWhitespace
+        private static bool StringIsEmptyOrWhitespace(string s) {
+            if (s == null) {
+                return false;
+            }
+
+            if (s.Length != 0) {
+                for (int i = 0; i < s.Length; i++) {
+                    if (!Char.IsWhiteSpace(s[i])) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        public static void ValidateBindingContext(ModelBindingContext bindingContext) {
+            if (bindingContext == null) {
+                throw new ArgumentNullException("bindingContext");
+            }
+
+            if (bindingContext.ModelMetadata == null) {
+                throw Error.ModelBinderUtil_ModelMetadataCannotBeNull();
+            }
+        }
+
+        public static void ValidateBindingContext(ModelBindingContext bindingContext, Type requiredType, bool allowNullModel) {
+            ValidateBindingContext(bindingContext);
+
+            if (bindingContext.ModelType != requiredType) {
+                throw Error.ModelBinderUtil_ModelTypeIsWrong(bindingContext.ModelType, requiredType);
+            }
+
+            if (!allowNullModel && bindingContext.Model == null) {
+                throw Error.ModelBinderUtil_ModelCannotBeNull(requiredType);
+            }
+
+            if (bindingContext.Model != null && !requiredType.IsInstanceOfType(bindingContext.Model)) {
+                throw Error.ModelBinderUtil_ModelInstanceIsWrong(bindingContext.Model.GetType(), requiredType);
+            }
+        }
+
+    }
+}