Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Extensions/Script/Services/WebServiceMethodData.cs

@@ -0,0 +1,201 @@
+//------------------------------------------------------------------------------
+// <copyright file="WebServiceMethodData.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Reflection;
+using System.Web.Resources;
+using System.Web.Script.Serialization;
+using System.Web.Services;
+
+namespace System.Web.Script.Services {
+
+    internal class WebServiceMethodData {
+        private MethodInfo _methodInfo;
+        private WebMethodAttribute _webMethodAttribute;
+        private ScriptMethodAttribute _scriptMethodAttribute;
+        private string _methodName;
+        private Dictionary<string, WebServiceParameterData> _parameterData;
+        private WebServiceData _owner;
+        private bool? _useHttpGet;
+
+        internal WebServiceMethodData(WebServiceData owner, MethodInfo methodInfo, WebMethodAttribute webMethodAttribute, ScriptMethodAttribute scriptMethodAttribute) {
+            _owner = owner;
+            _methodInfo = methodInfo;
+            _webMethodAttribute = webMethodAttribute;
+            _methodName = _webMethodAttribute.MessageName;
+            _scriptMethodAttribute = scriptMethodAttribute;
+            if (String.IsNullOrEmpty(_methodName)) {
+                _methodName = methodInfo.Name;
+            }
+        }
+        
+        // This constructor is only used by WCF. Owener, MethodName, ParameterDataDictionary, ParamterData
+        // are the only valid properties in WCF case.
+        internal WebServiceMethodData(WebServiceData owner, string methodName, Dictionary<string, WebServiceParameterData> parameterData, bool useHttpGet) {
+            _owner = owner;
+            _methodName = methodName;
+            _parameterData = parameterData;
+            _useHttpGet = useHttpGet;
+        }
+
+        internal WebServiceData Owner {
+            get {
+                return _owner;
+            }
+        }
+
+        private void EnsureParameters() {
+
+            // Build the parameters collection on demand
+            if (_parameterData != null)
+                return;
+
+            lock (this) {
+                Dictionary<string, WebServiceParameterData> parameterData = new Dictionary<string, WebServiceParameterData>();
+                int index = 0;
+                foreach (ParameterInfo param in _methodInfo.GetParameters()) {
+                    parameterData[param.Name] = new WebServiceParameterData(param, index);
+                    index++;
+                }
+                _parameterData = parameterData;
+            }
+        }
+
+        internal string MethodName {
+            get {
+                return _methodName;
+            }
+        }
+
+        internal MethodInfo MethodInfo {
+            get {
+                return _methodInfo;
+            }
+        }
+
+        internal IDictionary<string, WebServiceParameterData> ParameterDataDictionary {
+            get {
+                EnsureParameters();
+                return _parameterData;
+            }
+        }
+
+        internal ICollection<WebServiceParameterData> ParameterDatas {
+            get {
+                return ParameterDataDictionary.Values;
+            }
+        }
+
+        internal int CacheDuration {
+            get {
+                Debug.Assert(_webMethodAttribute != null); // If fails: WebserviceMethodData corrosponding to WCF is being used by ASMX JSON handler
+                return _webMethodAttribute.CacheDuration;
+            }
+        }
+
+        internal bool RequiresSession {
+            get {
+                Debug.Assert(_webMethodAttribute != null); // If fails: WebserviceMethodData corrosponding to WCF is being used by ASMX JSON handler
+                return _webMethodAttribute.EnableSession;
+            }
+        }
+
+        internal bool IsStatic {
+            get {
+                Debug.Assert(_methodInfo != null); // If fails: WebserviceMethodData corrosponding to WCF is being used by ASMX JSON handler
+                return _methodInfo.IsStatic;
+            }
+        }
+
+        internal Type ReturnType {
+            get {
+                Debug.Assert(_methodInfo != null); // If fails: WebserviceMethodData corrosponding to WCF is being used by ASMX JSON handler
+                return (_methodInfo == null) ? null : _methodInfo.ReturnType;
+            }
+        }
+        
+        internal bool UseXmlResponse {
+            get {
+                if (_scriptMethodAttribute != null) {
+                    return _scriptMethodAttribute.ResponseFormat == ResponseFormat.Xml;
+                }
+                return false;
+            }
+        }
+
+        internal bool XmlSerializeString {
+            get {
+                if (_scriptMethodAttribute != null) {
+                    return _scriptMethodAttribute.XmlSerializeString;
+                }
+                return false;
+            }
+        }
+
+        internal bool UseGet {
+            get {
+                if (_useHttpGet != null) {
+                    return _useHttpGet.Value;
+                }
+                if (_scriptMethodAttribute != null) {
+                    return _scriptMethodAttribute.UseHttpGet;
+                }
+                return false;
+            }
+        }
+
+        internal object CallMethodFromRawParams(object target, IDictionary<string, object> parameters) {
+            // Process the 'raw' parameters so that we use strongly typed objects when possible
+            parameters = StrongTypeParameters(parameters);
+            return CallMethod(target, parameters);
+        }
+
+        private object CallMethod(object target, IDictionary<string, object> parameters) {
+            // Make sure we have all the data about this method's parameters
+            EnsureParameters();
+
+            // Allocate an object array for all the formal parameters (whether passed in or not)
+            object[] actualParams = new object[_parameterData.Count];
+
+            // Go through all the actual parameters
+            foreach (WebServiceParameterData paramData in _parameterData.Values) {
+                object value;
+                if (parameters.TryGetValue(paramData.ParameterInfo.Name, out value)) {
+                    actualParams[paramData.Index] = value;
+                }
+                else {
+                    throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.WebService_MissingArg, paramData.ParameterInfo.Name));
+                }
+            }
+
+            // Make the actual method call
+            return _methodInfo.Invoke(target, actualParams);
+        }
+
+        private IDictionary<string, object> StrongTypeParameters(IDictionary<string, object> rawParams) {
+            Debug.Assert(ParameterDataDictionary != null);
+            IDictionary<string, WebServiceParameterData> paramDataDictionary = ParameterDataDictionary;
+
+            // Allocate a dictionary to hold the processed parameters.
+            IDictionary<string, object> result = new Dictionary<string, object>(rawParams.Count);
+
+            // Go through all the raw parameters
+            foreach (KeyValuePair<string, object> pair in rawParams) {
+                string memberName = pair.Key;
+                if (paramDataDictionary.ContainsKey(memberName)) {
+                    // Get the type of the formal parameter
+                    Type paramType = paramDataDictionary[memberName].ParameterInfo.ParameterType;
+
+                    // Convert the raw parameter based on that type
+                    result[memberName] = ObjectConverter.ConvertObjectToType(pair.Value, paramType, Owner.Serializer);
+                }
+            }
+            return result;
+        }
+    }
+}