mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
562 lines
25 KiB
C#
562 lines
25 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="WebServiceData.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Script.Services {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Security;
|
|
using System.Web;
|
|
using System.Web.Caching;
|
|
using System.Web.Compilation;
|
|
using System.Web.Configuration;
|
|
using System.Web.Hosting;
|
|
using System.Web.Resources;
|
|
using System.Web.Script.Serialization;
|
|
using System.Web.Services;
|
|
|
|
internal class WebServiceData : JavaScriptTypeResolver {
|
|
private WebServiceTypeData _typeData;
|
|
private bool _pageMethods; // True for page methods(which only look at static methods)
|
|
private Dictionary<string, WebServiceMethodData> _methods;
|
|
|
|
// this is used to map __type ids in the JSON string to something other than type.FullName
|
|
private Dictionary<string, string> _typeResolverSpecials = new Dictionary<string, string>();
|
|
private Dictionary<string, WebServiceTypeData> _clientTypesDictionary;
|
|
private Dictionary<Type, string> _clientTypeNameDictionary;
|
|
private Dictionary<string, WebServiceEnumData> _enumTypesDictionary;
|
|
private Hashtable _processedTypes;
|
|
private bool _clientTypesProcessed;
|
|
|
|
private JavaScriptSerializer _serializer;
|
|
internal JavaScriptSerializer Serializer {
|
|
get {
|
|
return _serializer;
|
|
}
|
|
}
|
|
|
|
|
|
internal const string _profileServiceFileName = "Profile_JSON_AppService.axd";
|
|
internal const string _authenticationServiceFileName = "Authentication_JSON_AppService.axd";
|
|
internal const string _roleServiceFileName = "Role_JSON_AppService.axd";
|
|
|
|
private static WebServiceData GetApplicationService(string appRelativePath) {
|
|
// we only support the application services being accessed at the root level, so that url authorization can be used to control their access.
|
|
// In other words, "~/Profile_JSON_AppService.axd" should work but not "~/SomeSubDir/Profile_JSON_AppService.axd".
|
|
// AppRelativeCurrentExecutionFilePath looks like "~/path/filename.ext".
|
|
// So we can easily detect if the file requested is in the root by ensuring that the last index of "/" is == 1,
|
|
// as in the path "~/rootfile.ext", where "/" is the second character.
|
|
// Note that the WebServiceData object is cached higher in the stack once calculated
|
|
int slashIndex = appRelativePath.LastIndexOf('/');
|
|
if (slashIndex == 1) {
|
|
// it is a root file. Now see if its one of the two built in services
|
|
string name = Path.GetFileName(appRelativePath);
|
|
|
|
if (name.Equals(_profileServiceFileName, StringComparison.OrdinalIgnoreCase)) {
|
|
return new WebServiceData(typeof(System.Web.Profile.ProfileService), false);
|
|
}
|
|
else if (name.Equals(_authenticationServiceFileName, StringComparison.OrdinalIgnoreCase)) {
|
|
return new WebServiceData(typeof(System.Web.Security.AuthenticationService), false);
|
|
}
|
|
else if (name.Equals(_roleServiceFileName, StringComparison.OrdinalIgnoreCase)) {
|
|
return new WebServiceData(typeof(System.Web.Security.RoleService), false);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
internal static WebServiceData GetWebServiceData(HttpContext context, string virtualPath) {
|
|
return GetWebServiceData(context, virtualPath, true /*failIfNoData*/, false /*pageMethods*/, false/*inlineScript*/);
|
|
}
|
|
|
|
private static string GetCacheKey(string virtualPath) {
|
|
return "System.Web.Script.Services.WebServiceData:" + virtualPath;
|
|
}
|
|
|
|
internal static WebServiceData GetWebServiceData(HttpContext context, string virtualPath, bool failIfNoData, bool pageMethods) {
|
|
return GetWebServiceData(context, virtualPath, failIfNoData, pageMethods, false /*inlineScript*/);
|
|
}
|
|
|
|
[SecuritySafeCritical]
|
|
internal static WebServiceData GetWebServiceData(HttpContext context, string virtualPath, bool failIfNoData, bool pageMethods, bool inlineScript) {
|
|
// Make sure the path is cannonical to avoid doing more work than necessary
|
|
virtualPath = VirtualPathUtility.ToAbsolute(virtualPath);
|
|
|
|
string cacheKey = GetCacheKey(virtualPath);
|
|
WebServiceData data = context.Cache[cacheKey] as WebServiceData;
|
|
|
|
// Handle the case where the virtualPath exists, for example a real asmx page.
|
|
if (data == null) {
|
|
if (HostingEnvironment.VirtualPathProvider.FileExists(virtualPath)) {
|
|
Type compiledType = null;
|
|
try {
|
|
compiledType = BuildManager.GetCompiledType(virtualPath);
|
|
|
|
// If we can't get the compiled type, try creating an instance (i.e. for no compile pages)
|
|
if (compiledType == null) {
|
|
object page = BuildManager.CreateInstanceFromVirtualPath(virtualPath, typeof(System.Web.UI.Page));
|
|
if (page != null) {
|
|
compiledType = page.GetType();
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (SecurityException) {
|
|
// DevDiv 33708: BuildManager requires Medium trust, so we need to no-op rather than
|
|
// destroying the page.
|
|
}
|
|
|
|
if (compiledType != null) {
|
|
data = new WebServiceData(compiledType, pageMethods);
|
|
BuildDependencySet deps = BuildManager.GetCachedBuildDependencySet(context, virtualPath);
|
|
if (deps != null) {
|
|
// Dev10 718863: It's possible 'deps' is null if the service is modified between GetCompiledType and here.
|
|
// in that case simply do not cache the result so it is re-established next time it is required.
|
|
CacheDependency cd = HostingEnvironment.VirtualPathProvider.GetCacheDependency(virtualPath, deps.VirtualPaths, DateTime.Now);
|
|
context.Cache.Insert(cacheKey, data, cd);
|
|
}
|
|
}
|
|
}
|
|
else if (virtualPath.EndsWith("_AppService.axd", StringComparison.OrdinalIgnoreCase)) {
|
|
// File does not exist, but the url may be a request for one of the three built-in services: ProfileService, AuthenticationService, RoleService
|
|
data = WebServiceData.GetApplicationService(context.Request.AppRelativeCurrentExecutionFilePath);
|
|
if (data != null) {
|
|
context.Cache.Insert(cacheKey, data);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (data == null) {
|
|
if (failIfNoData) {
|
|
if (inlineScript) {
|
|
//DevDiv 74432: InlineScript = true fails, for WCF serviceReferences: Need an appropriate error message
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.WebService_NoWebServiceDataInlineScript, virtualPath));
|
|
}
|
|
else {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.WebService_NoWebServiceData, virtualPath));
|
|
}
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
internal WebServiceData() {
|
|
}
|
|
|
|
private WebServiceData(WebServiceTypeData typeData) {
|
|
_typeData = typeData;
|
|
_serializer = new JavaScriptSerializer(this);
|
|
#pragma warning disable 0436
|
|
ScriptingJsonSerializationSection.ApplicationSettings settings = new ScriptingJsonSerializationSection.ApplicationSettings();
|
|
#pragma warning restore 0436
|
|
_serializer.MaxJsonLength = settings.MaxJsonLimit;
|
|
_serializer.RecursionLimit = settings.RecursionLimit;
|
|
_serializer.RegisterConverters(settings.Converters);
|
|
}
|
|
|
|
// Normal ASMX Atlas codepath for creating webservice data
|
|
internal WebServiceData(Type type, bool pageMethods)
|
|
: this(new WebServiceTypeData(type.Name, type.Namespace, type)) {
|
|
_pageMethods = pageMethods;
|
|
// Pages don't need to have script service attribute
|
|
if (!_pageMethods) {
|
|
object[] attribs = type.GetCustomAttributes(typeof(ScriptServiceAttribute), true);
|
|
if (attribs.Length == 0) {
|
|
throw new InvalidOperationException(AtlasWeb.WebService_NoScriptServiceAttribute);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Indigo entry point for creating WebServiceData
|
|
internal WebServiceData(WebServiceTypeData typeData, Dictionary<string, WebServiceMethodData> methods)
|
|
: this(typeData) {
|
|
_methods = methods;
|
|
}
|
|
|
|
private void AddMethod(Dictionary<string, WebServiceMethodData> methods, MethodInfo method) {
|
|
object[] wmAttribs = method.GetCustomAttributes(typeof(WebMethodAttribute), true);
|
|
|
|
// Skip it if it doesn't have the WebMethod attribute
|
|
if (wmAttribs.Length == 0)
|
|
return;
|
|
|
|
ScriptMethodAttribute sm = null;
|
|
object[] responseAttribs = method.GetCustomAttributes(typeof(ScriptMethodAttribute), true);
|
|
if (responseAttribs.Length > 0) {
|
|
sm = (ScriptMethodAttribute)responseAttribs[0];
|
|
}
|
|
|
|
// Create an object to keep track of this method's data
|
|
WebServiceMethodData wmd = new WebServiceMethodData(this, method, (WebMethodAttribute)wmAttribs[0], sm);
|
|
methods[wmd.MethodName] = wmd;
|
|
}
|
|
|
|
private void EnsureMethods() {
|
|
// Type will only be null for the Indigo code path
|
|
if (_methods != null || _typeData.Type == null)
|
|
return;
|
|
|
|
// Build the method collection on demand
|
|
lock (this) {
|
|
|
|
// Need to add the methods of each type in reverse order
|
|
List<Type> typeList = new List<Type>();
|
|
Type current = _typeData.Type;
|
|
typeList.Add(current);
|
|
while (current.BaseType != null) {
|
|
current = current.BaseType;
|
|
typeList.Add(current);
|
|
}
|
|
Dictionary<string, WebServiceMethodData> methods = new Dictionary<string, WebServiceMethodData>(StringComparer.OrdinalIgnoreCase);
|
|
BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly;
|
|
if (_pageMethods) flags |= BindingFlags.Static;
|
|
else flags |= BindingFlags.Instance;
|
|
|
|
// Add the methods in reverse order from base to derived
|
|
for (int i = typeList.Count - 1; i >= 0; --i) {
|
|
MethodInfo[] methodInfos = typeList[i].GetMethods(flags);
|
|
foreach (MethodInfo method in methodInfos) {
|
|
AddMethod(methods, method);
|
|
}
|
|
}
|
|
_methods = methods;
|
|
}
|
|
}
|
|
|
|
internal WebServiceTypeData TypeData {
|
|
get { return _typeData; }
|
|
}
|
|
|
|
internal ICollection<WebServiceMethodData> MethodDatas {
|
|
get {
|
|
EnsureMethods();
|
|
return _methods.Values;
|
|
}
|
|
}
|
|
|
|
internal void ClearProcessedTypes() {
|
|
_processedTypes = null;
|
|
}
|
|
|
|
internal void Initialize(WebServiceTypeData typeData, Dictionary<string, WebServiceMethodData> methods) {
|
|
Dictionary<string, WebServiceTypeData> clientTypeDictionary = new Dictionary<string, WebServiceTypeData>();
|
|
_clientTypesDictionary = clientTypeDictionary;
|
|
Dictionary<string, WebServiceEnumData> enumTypeDictionary = new Dictionary<string, WebServiceEnumData>();
|
|
_enumTypesDictionary = enumTypeDictionary;
|
|
_processedTypes = new Hashtable();
|
|
_clientTypesProcessed = true;
|
|
_clientTypeNameDictionary = new Dictionary<Type, string>();
|
|
_typeData = typeData;
|
|
_methods = methods;
|
|
}
|
|
|
|
internal WebServiceMethodData GetMethodData(string methodName) {
|
|
EnsureMethods();
|
|
|
|
// Fail if the web method doesn't exist
|
|
WebServiceMethodData methodData = null;
|
|
if (!_methods.TryGetValue(methodName, out methodData)) {
|
|
throw new ArgumentException(
|
|
String.Format(CultureInfo.CurrentCulture, AtlasWeb.WebService_UnknownWebMethod, methodName), "methodName");
|
|
}
|
|
|
|
EnsureClientTypesProcessed();
|
|
return methodData;
|
|
}
|
|
|
|
private void EnsureClientTypesProcessed() {
|
|
if (_clientTypesProcessed)
|
|
return;
|
|
|
|
lock (this) {
|
|
if (_clientTypesProcessed)
|
|
return;
|
|
ProcessClientTypes();
|
|
}
|
|
}
|
|
|
|
private void ProcessClientTypes() {
|
|
Debug.Assert(!_clientTypesProcessed, "ProcessClientTypes shouldn't be called after it has already been successfully run.");
|
|
|
|
// List of types that can be instantiated on the client
|
|
_clientTypesDictionary = new Dictionary<string, WebServiceTypeData>();
|
|
_enumTypesDictionary = new Dictionary<string, WebServiceEnumData>();
|
|
|
|
_clientTypeNameDictionary = new Dictionary<Type, string>();
|
|
|
|
try {
|
|
// _processedTypes is used to avoid processing a Type more than once
|
|
_processedTypes = new Hashtable();
|
|
|
|
// Process any GenerateScriptTypes on the Service type
|
|
ProcessIncludeAttributes((GenerateScriptTypeAttribute[])_typeData.Type.GetCustomAttributes(typeof(GenerateScriptTypeAttribute), true));
|
|
|
|
foreach (WebServiceMethodData methodData in MethodDatas) {
|
|
|
|
// Process any GenerateScriptTypes on the method
|
|
ProcessIncludeAttributes((GenerateScriptTypeAttribute[])methodData.MethodInfo.GetCustomAttributes(typeof(GenerateScriptTypeAttribute), true));
|
|
|
|
// Also add any input parameters
|
|
foreach (WebServiceParameterData paramData in methodData.ParameterDatas) {
|
|
ProcessClientType(paramData.ParameterInfo.ParameterType);
|
|
}
|
|
|
|
// Ignore return type if it uses XML instead of JSON
|
|
if (methodData.UseXmlResponse) continue;
|
|
ProcessClientType(methodData.ReturnType);
|
|
}
|
|
|
|
// DevDiv 60672: Only set to true if the proxies were SUCCESSFULLY processed
|
|
// Only setting _clientTypesProcessed=true on success will cause us to retry creating the proxies each
|
|
// request when there is an exception, and so the same exception will be thrown each time.
|
|
_clientTypesProcessed = true;
|
|
}
|
|
catch {
|
|
// If we have any exception we have to null out our caches
|
|
_clientTypesDictionary = null;
|
|
_enumTypesDictionary = null;
|
|
_clientTypeNameDictionary = null;
|
|
throw;
|
|
}
|
|
finally {
|
|
_processedTypes = null;
|
|
}
|
|
}
|
|
|
|
private void ProcessIncludeAttributes(GenerateScriptTypeAttribute[] attributes) {
|
|
foreach (GenerateScriptTypeAttribute attribute in attributes) {
|
|
if (!String.IsNullOrEmpty(attribute.ScriptTypeId))
|
|
_typeResolverSpecials[attribute.Type.FullName] = attribute.ScriptTypeId;
|
|
|
|
Type t = attribute.Type;
|
|
if (t.IsPrimitive || t == typeof(object) || t == typeof(string) ||
|
|
t == typeof(DateTime) || t == typeof(Guid) ||
|
|
typeof(IEnumerable).IsAssignableFrom(t) || typeof(IDictionary).IsAssignableFrom(t) ||
|
|
(t.IsGenericType && t.GetGenericArguments().Length > 1) ||
|
|
!ObjectConverter.IsClientInstantiatableType(t, _serializer))
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.WebService_InvalidGenerateScriptType, t.FullName));
|
|
|
|
ProcessClientType(t, true);
|
|
}
|
|
}
|
|
|
|
private void ProcessClientType(Type t) {
|
|
ProcessClientType(t, false, false);
|
|
}
|
|
|
|
|
|
private void ProcessClientType(Type t, bool force) {
|
|
ProcessClientType(t, force, false);
|
|
}
|
|
|
|
// Force = true is required for when we detect a GenerateScriptType which may supply a new ScriptTypeID
|
|
[SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_clientTypeNameDictionary", Justification = "This is used by ASP.Net web services which is a legacy technology.")]
|
|
internal void ProcessClientType(Type t, bool force, bool isWCF)
|
|
{
|
|
if (!force && _processedTypes.Contains(t))
|
|
return;
|
|
_processedTypes[t] = null;
|
|
|
|
// Keep track of all enum Types
|
|
if (t.IsEnum) {
|
|
WebServiceEnumData enumData = null;
|
|
if (isWCF) {
|
|
enumData = (WebServiceEnumData)WebServiceTypeData.GetWebServiceTypeData(t);
|
|
}
|
|
else {
|
|
enumData = new WebServiceEnumData(t.Name, t.Namespace, t, Enum.GetNames(t), Enum.GetValues(t), Enum.GetUnderlyingType(t) == typeof(ulong));
|
|
}
|
|
_enumTypesDictionary[GetTypeStringRepresentation(enumData.TypeName, false)] = enumData;
|
|
return;
|
|
}
|
|
|
|
// For generics, we only allow generic types with one parameter, which we will try to process
|
|
if (t.IsGenericType) {
|
|
if (isWCF) {
|
|
ProcessKnownTypes(t);
|
|
}
|
|
else {
|
|
Type[] genericArgs = t.GetGenericArguments();
|
|
if (genericArgs.Length > 1) {
|
|
return;
|
|
}
|
|
ProcessClientType(genericArgs[0], false, isWCF);
|
|
}
|
|
}
|
|
// Support arrays explicitly
|
|
else if (t.IsArray) {
|
|
ProcessClientType(t.GetElementType(), false, isWCF);
|
|
}
|
|
else {
|
|
// Ignore primitive types
|
|
// Ignore DateTime, since we have special serialization handling for it in the JavaScriptSerializer
|
|
// Ignore IDctionary and IEnumerables as well
|
|
if (t.IsPrimitive || t == typeof(object) || t == typeof(string) || t == typeof(DateTime) ||
|
|
t == typeof(void) || t == typeof(System.Decimal) || t == typeof(Guid) ||
|
|
typeof(IEnumerable).IsAssignableFrom(t) || typeof(IDictionary).IsAssignableFrom(t) ||
|
|
(!isWCF && !ObjectConverter.IsClientInstantiatableType(t, _serializer)))
|
|
return;
|
|
|
|
// Only add it to the list of client types if it can be instantiated.
|
|
// pass false to skip the lock
|
|
if (isWCF) {
|
|
ProcessKnownTypes(t);
|
|
}
|
|
else {
|
|
string typeStringRepresentation = GetTypeStringRepresentation(t.FullName, false);
|
|
_clientTypesDictionary[typeStringRepresentation] = new WebServiceTypeData(t.Name, t.Namespace, t);
|
|
_clientTypeNameDictionary[t] = typeStringRepresentation;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_clientTypeNameDictionary", Justification = "This is used by ASP.Net web services which is a legacy technology. Fun fact : The current code path suggests that this method is never hit!!")]
|
|
private void ProcessKnownTypes(Type t)
|
|
{
|
|
WebServiceTypeData typeData = WebServiceTypeData.GetWebServiceTypeData(t);
|
|
bool alreadyProcessed = false;
|
|
if (typeData == null) {
|
|
// indicates a type was used that is a built-in type
|
|
return;
|
|
}
|
|
|
|
// if T implments IEnumerable or IDictionary, do not include type proxy for it
|
|
// but still continue to get known types. I.e List<MyType> should ignore List<MyType>
|
|
// but process MyType
|
|
if (!(typeof(IEnumerable).IsAssignableFrom(t) || typeof(IDictionary).IsAssignableFrom(t))) {
|
|
_clientTypeNameDictionary[t] = GetTypeStringRepresentation(typeData.TypeName);
|
|
alreadyProcessed = ProcessTypeData(typeData);
|
|
}
|
|
|
|
if (!alreadyProcessed) {
|
|
IList<WebServiceTypeData> knownTypes = WebServiceTypeData.GetKnownTypes(t, typeData);
|
|
foreach (WebServiceTypeData knownType in knownTypes) {
|
|
ProcessTypeData(knownType);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// returns true if typeData already exists in typeDictionary
|
|
private bool ProcessTypeData(WebServiceTypeData typeData) {
|
|
string typeString = GetTypeStringRepresentation(typeData.TypeName);
|
|
bool retval = true;
|
|
if (typeData is WebServiceEnumData) {
|
|
if (!_enumTypesDictionary.ContainsKey(typeString)) {
|
|
_enumTypesDictionary[typeString] = (WebServiceEnumData)typeData;
|
|
retval = false;
|
|
}
|
|
}
|
|
else {
|
|
if (!_clientTypesDictionary.ContainsKey(typeString)) {
|
|
_clientTypesDictionary[typeString] = typeData;
|
|
retval = false;
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
|
|
internal IEnumerable<WebServiceTypeData> ClientTypes {
|
|
get {
|
|
return ClientTypeDictionary.Values;
|
|
}
|
|
}
|
|
|
|
internal Dictionary<string, WebServiceTypeData> ClientTypeDictionary {
|
|
get {
|
|
EnsureClientTypesProcessed();
|
|
return _clientTypesDictionary;
|
|
}
|
|
set {
|
|
_clientTypesDictionary = value;
|
|
}
|
|
}
|
|
|
|
internal Dictionary<Type, string> ClientTypeNameDictionary {
|
|
get {
|
|
EnsureClientTypesProcessed();
|
|
return _clientTypeNameDictionary;
|
|
}
|
|
}
|
|
|
|
internal IEnumerable<WebServiceEnumData> EnumTypes {
|
|
get {
|
|
EnsureClientTypesProcessed();
|
|
return _enumTypesDictionary.Values;
|
|
}
|
|
}
|
|
|
|
internal Dictionary<string, WebServiceEnumData> EnumTypeDictionary {
|
|
get {
|
|
EnsureClientTypesProcessed();
|
|
return _enumTypesDictionary;
|
|
}
|
|
set {
|
|
_enumTypesDictionary = value;
|
|
}
|
|
}
|
|
|
|
public override Type ResolveType(string id) {
|
|
WebServiceTypeData type = null;
|
|
if (ClientTypeDictionary.TryGetValue(id, out type)) {
|
|
if (type != null) {
|
|
return type.Type;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public override string ResolveTypeId(Type type) {
|
|
string typeString = GetTypeStringRepresentation(type.FullName);
|
|
|
|
// If this type is not in the dictionary
|
|
if (!ClientTypeDictionary.ContainsKey(typeString))
|
|
return null;
|
|
|
|
return typeString;
|
|
}
|
|
|
|
internal string GetTypeStringRepresentation(string typeName) {
|
|
return GetTypeStringRepresentation(typeName, true);
|
|
}
|
|
|
|
internal string GetTypeStringRepresentation(string typeName, bool ensure) {
|
|
if (ensure) {
|
|
EnsureClientTypesProcessed();
|
|
}
|
|
|
|
// Handle special cases from GenerateScriptType first
|
|
string typeString;
|
|
if (_typeResolverSpecials.TryGetValue(typeName, out typeString)) {
|
|
return typeString;
|
|
}
|
|
return typeName;
|
|
}
|
|
|
|
internal string GetTypeStringRepresentation(WebServiceTypeData typeData) {
|
|
//First check if typeData provides its string representaiton ( for WCF case)
|
|
string typeString = typeData.StringRepresentation;
|
|
if (typeString == null) {
|
|
typeString = GetTypeStringRepresentation(typeData.TypeName, true);
|
|
}
|
|
return typeString;
|
|
}
|
|
}
|
|
}
|