|
//------------------------------------------------------------------------------
// <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;
}
}
}
|