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