Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Web.Extensions/Script/Services/ServicesUtilities.cs

@@ -0,0 +1,125 @@
+//------------------------------------------------------------------------------
+// <copyright file="ServicesUtilities.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace System.Web.Script.Services {
+    internal static class ServicesUtilities {
+        
+        internal static string GetClientTypeName(string name) {
+            // e.g. MyNS.MySubNS.MyWebService OR var MyWebService
+            return name.Replace('+', '_');
+        }
+
+        [SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "System.Collections.Generic.Dictionary`2<System.Type,System.String>", Justification = "This is used by ASP.Net web services which is a legacy technology.")]
+        internal static string GetClientTypeFromServerType(WebServiceData webServiceData, Type type)
+        {
+            // For intellisense purposes, returns a best estimate of what the appropriate client-side type is for a given server type.
+            // Takes generated client proxies and enum proxies into consideration.
+            // The rest is a best guess.
+            // If all else fails we use "", to indicate "any" client side type. "Object" is not the same as any type on the client since
+            // string, for example, is not considered an object. "Object" is equiv to a .net dictionary.
+
+
+
+            if (webServiceData.ClientTypeNameDictionary.ContainsKey(type)) {
+                // if it exists in the client type dictionary, it will have a proxy generated for it
+                //get the client based on type.FullName for ASMX, and schema qualified name and namespace for WCF
+                return webServiceData.ClientTypeNameDictionary[type];
+            }
+
+            if (type.IsEnum) {
+                // there will be a proxy for this enum
+                return GetClientTypeName(type.FullName);
+            }
+
+            // there is no client proxy for it, so it either maps to a built-in js type or it could be "anything"
+
+            // take care of the most common types
+            if (type == typeof(string) || type == typeof(char)) {
+                return "String";
+            }
+            else if (type.IsPrimitive) {
+                // The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64 (long), UInt64, IntPtr, Char, Double, and Single (float).
+                if (type == typeof(bool)) {
+                    // bool is the only primitive we shouldnt treat as a number
+                    return "Boolean";
+                }
+                else {
+                    // takes care of all ints, float, double, but not decimal since it isnt a primitive
+                    // we also consider byte, sbyte, and intptr to be numbers
+                    return "Number";
+                }
+            }
+
+            if (type.IsValueType) {
+                if (type == typeof(DateTime)) {
+                    return "Date";
+                }
+                else if (type == typeof(Guid)) {
+                    return "String";
+                }
+                else if (type == typeof(Decimal)) {
+                    return "Number";
+                }
+            }
+
+            if (typeof(IDictionary).IsAssignableFrom(type)) {
+                return "Object";
+            }
+            // might still be IDictionary<K,T>
+            if (type.IsGenericType) {
+                Type gtd = type;
+                if (!type.IsGenericTypeDefinition) {
+                    gtd = type.GetGenericTypeDefinition();
+                }
+                if (gtd == typeof(IDictionary<,>)) {
+                    return "Object";
+                }
+            }
+
+            if (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type)) {
+                return "Array";
+            }
+
+            // dont know what it is (e.g., TimeSpan), or it is type Object, so allow any client type.
+            return "";
+        }
+
+        internal static Type UnwrapNullableType(Type type) {
+            // check for nullable<t> and pull out <t>
+            if (type.IsGenericType && !type.IsGenericTypeDefinition) {
+                Type genericTypeDefinition = type.GetGenericTypeDefinition();
+                if (genericTypeDefinition == typeof(Nullable<>)) {
+                    return type.GetGenericArguments()[0];
+                }
+            }
+
+            return type;
+        }
+
+        
+        // Serialize an object to an XML string
+        internal static string XmlSerializeObjectToString(object obj) {
+            // 
+            XmlSerializer xs = new XmlSerializer(obj.GetType());
+            MemoryStream ms = new MemoryStream();
+            using (XmlTextWriter writer = new XmlTextWriter(ms, Encoding.UTF8)) {
+                xs.Serialize(writer, obj);
+                ms.Position = 0;
+                using (StreamReader reader = new StreamReader(ms)) {
+                    return reader.ReadToEnd();
+                }
+            }
+        }
+    }
+}