Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

456 lines
25 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="ClientProxyGenerator.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.Text;
using System.Web;
using System.Web.Script.Serialization;
internal abstract class ClientProxyGenerator {
private static string DebugXmlComments = @"/// <param name=""succeededCallback"" type=""Function"" optional=""true"" mayBeNull=""true""></param>
/// <param name=""failedCallback"" type=""Function"" optional=""true"" mayBeNull=""true""></param>
/// <param name=""userContext"" optional=""true"" mayBeNull=""true""></param>
";
private Hashtable _registeredNamespaces = new Hashtable();
private Hashtable _ensuredObjectParts = new Hashtable();
protected StringBuilder _builder;
protected bool _debugMode;
// comments are the same in the instance methods as they are in the static methods
// this cache is used when calculating comments for instance methods, then re-used when
// writing out static methods.
private Dictionary<string, string> _docCommentCache;
internal string GetClientProxyScript(WebServiceData webServiceData) {
if (webServiceData.MethodDatas.Count == 0) return null;
_builder = new StringBuilder();
if (_debugMode) {
_docCommentCache = new Dictionary<string, string>();
}
// Constructor
GenerateConstructor(webServiceData);
// Prototype functions
GeneratePrototype(webServiceData);
GenerateRegisterClass(webServiceData);
GenerateStaticInstance(webServiceData);
GenerateStaticMethods(webServiceData);
// Generate some client proxy to make some types instantiatable on the client
GenerateClientTypeProxies(webServiceData);
GenerateEnumTypeProxies(webServiceData.EnumTypes);
return _builder.ToString();
}
protected void GenerateRegisterClass(WebServiceData webServiceData) {
// Generate registerClass: Foo.NS.WebService.registerClass('Foo.NS.WebService', Sys.Net.WebServiceProxy);
string typeName = GetProxyTypeName(webServiceData);
_builder.Append(typeName).Append(".registerClass('").Append(typeName).Append("',Sys.Net.WebServiceProxy);\r\n");
}
protected virtual void GenerateConstructor(WebServiceData webServiceData) {
GenerateTypeDeclaration(webServiceData, false);
_builder.Append("function() {\r\n");
_builder.Append(GetProxyTypeName(webServiceData)).Append(".initializeBase(this);\r\n");
GenerateFields();
_builder.Append("}\r\n");
}
protected virtual void GeneratePrototype(WebServiceData webServiceData) {
GenerateTypeDeclaration(webServiceData, true);
_builder.Append("{\r\n");
// private method to return the path to be used , returns _path from current instance if set, otherwise returns _path from static instance.
_builder.Append("_get_path:function() {\r\n var p = this.get_path();\r\n if (p) return p;\r\n else return ");
_builder.Append(GetProxyTypeName(webServiceData)).Append("._staticInstance.get_path();},\r\n");
bool first = true;
foreach (WebServiceMethodData methodData in webServiceData.MethodDatas) {
if (!first) {
_builder.Append(",\r\n");
}
first = false;
GenerateWebMethodProxy(methodData);
}
_builder.Append("}\r\n");
}
protected virtual void GenerateTypeDeclaration(WebServiceData webServiceData, bool genClass) {
AppendClientTypeDeclaration(webServiceData.TypeData.TypeNamespace, webServiceData.TypeData.TypeName, genClass, true);
}
protected void GenerateFields() {
_builder.Append("this._timeout = 0;\r\n");
_builder.Append("this._userContext = null;\r\n");
_builder.Append("this._succeeded = null;\r\n");
_builder.Append("this._failed = null;\r\n");
}
protected virtual void GenerateMethods() {
}
protected void GenerateStaticMethods(WebServiceData webServiceData) {
string className = GetProxyTypeName(webServiceData);
// Now generate static methods NS.Service.MyMethod = function()
foreach (WebServiceMethodData methodData in webServiceData.MethodDatas) {
string methodName = methodData.MethodName;
_builder.Append(className).Append('.').Append(methodName).Append("= function(");
StringBuilder argBuilder = new StringBuilder();
bool first = true;
foreach (WebServiceParameterData paramData in methodData.ParameterDatas) {
if (!first) argBuilder.Append(',');
else first = false;
argBuilder.Append(paramData.ParameterName);
}
if (!first) argBuilder.Append(',');
argBuilder.Append("onSuccess,onFailed,userContext");
_builder.Append(argBuilder.ToString()).Append(") {");
if (_debugMode) {
// doc comments should have been computed already
_builder.Append("\r\n");
_builder.Append(_docCommentCache[methodName]);
}
_builder.Append(className).Append("._staticInstance.").Append(methodName).Append('(');
_builder.Append(argBuilder.ToString()).Append("); }\r\n");
}
}
protected abstract string GetProxyPath();
protected virtual string GetJsonpCallbackParameterName() {
return null;
}
protected virtual bool GetSupportsJsonp() {
return false;
}
protected void GenerateStaticInstance(WebServiceData data) {
string typeName = GetProxyTypeName(data);
_builder.Append(typeName).Append("._staticInstance = new ").Append(typeName).Append("();\r\n");
// Generate the static properties
if (_debugMode) {
_builder.Append(typeName).Append(".set_path = function(value) {\r\n");
_builder.Append(typeName).Append("._staticInstance.set_path(value); }\r\n");
_builder.Append(typeName).Append(".get_path = function() { \r\n/// <value type=\"String\" mayBeNull=\"true\">The service url.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_path();}\r\n");
_builder.Append(typeName).Append(".set_timeout = function(value) {\r\n");
_builder.Append(typeName).Append("._staticInstance.set_timeout(value); }\r\n");
_builder.Append(typeName).Append(".get_timeout = function() { \r\n/// <value type=\"Number\">The service timeout.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_timeout(); }\r\n");
_builder.Append(typeName).Append(".set_defaultUserContext = function(value) { \r\n");
_builder.Append(typeName).Append("._staticInstance.set_defaultUserContext(value); }\r\n");
_builder.Append(typeName).Append(".get_defaultUserContext = function() { \r\n/// <value mayBeNull=\"true\">The service default user context.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_defaultUserContext(); }\r\n");
_builder.Append(typeName).Append(".set_defaultSucceededCallback = function(value) { \r\n ");
_builder.Append(typeName).Append("._staticInstance.set_defaultSucceededCallback(value); }\r\n");
_builder.Append(typeName).Append(".get_defaultSucceededCallback = function() { \r\n/// <value type=\"Function\" mayBeNull=\"true\">The service default succeeded callback.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_defaultSucceededCallback(); }\r\n");
_builder.Append(typeName).Append(".set_defaultFailedCallback = function(value) { \r\n");
_builder.Append(typeName).Append("._staticInstance.set_defaultFailedCallback(value); }\r\n");
_builder.Append(typeName).Append(".get_defaultFailedCallback = function() { \r\n/// <value type=\"Function\" mayBeNull=\"true\">The service default failed callback.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_defaultFailedCallback(); }\r\n");
_builder.Append(typeName).Append(".set_enableJsonp = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_enableJsonp(value); }\r\n");
_builder.Append(typeName).Append(".get_enableJsonp = function() { \r\n/// <value type=\"Boolean\">Specifies whether the service supports JSONP for cross domain calling.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_enableJsonp(); }\r\n");
_builder.Append(typeName).Append(".set_jsonpCallbackParameter = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_jsonpCallbackParameter(value); }\r\n");
_builder.Append(typeName).Append(".get_jsonpCallbackParameter = function() { \r\n/// <value type=\"String\">Specifies the parameter name that contains the callback function name for a JSONP request.</value>\r\nreturn ");
_builder.Append(typeName).Append("._staticInstance.get_jsonpCallbackParameter(); }\r\n");
}
else {
_builder.Append(typeName).Append(".set_path = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_path(value); }\r\n");
_builder.Append(typeName).Append(".get_path = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_path(); }\r\n");
_builder.Append(typeName).Append(".set_timeout = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_timeout(value); }\r\n");
_builder.Append(typeName).Append(".get_timeout = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_timeout(); }\r\n");
_builder.Append(typeName).Append(".set_defaultUserContext = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_defaultUserContext(value); }\r\n");
_builder.Append(typeName).Append(".get_defaultUserContext = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_defaultUserContext(); }\r\n");
_builder.Append(typeName).Append(".set_defaultSucceededCallback = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_defaultSucceededCallback(value); }\r\n");
_builder.Append(typeName).Append(".get_defaultSucceededCallback = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_defaultSucceededCallback(); }\r\n");
_builder.Append(typeName).Append(".set_defaultFailedCallback = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_defaultFailedCallback(value); }\r\n");
_builder.Append(typeName).Append(".get_defaultFailedCallback = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_defaultFailedCallback(); }\r\n");
_builder.Append(typeName).Append(".set_enableJsonp = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_enableJsonp(value); }\r\n");
_builder.Append(typeName).Append(".get_enableJsonp = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_enableJsonp(); }\r\n");
_builder.Append(typeName).Append(".set_jsonpCallbackParameter = function(value) { ");
_builder.Append(typeName).Append("._staticInstance.set_jsonpCallbackParameter(value); }\r\n");
_builder.Append(typeName).Append(".get_jsonpCallbackParameter = function() { return ");
_builder.Append(typeName).Append("._staticInstance.get_jsonpCallbackParameter(); }\r\n");
}
// the path has to be the full absolete path if this is a JSONP enabled service. But it is the responsibility
// of the caller to GetClientProxyScript to pass the full path if appropriate since determining it may be
// dependant on the specific technology.
string proxyPath = GetProxyPath();
if (!String.IsNullOrEmpty(proxyPath) && (proxyPath.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || proxyPath.StartsWith("https://", StringComparison.OrdinalIgnoreCase))) {
// DevDiv 91322: avoid url encoding the domain portion of an IDN url
// find the first "/" after the scheme, and only encode after that.
int domainStart = proxyPath.IndexOf("://", StringComparison.OrdinalIgnoreCase) + "://".Length;
int domainEnd = proxyPath.IndexOf("/", domainStart, StringComparison.OrdinalIgnoreCase);
// if no slash after :// was found, it could be a domain only url, http://[some service].com, don't encode any of it
if (domainEnd != -1) {
proxyPath = proxyPath.Substring(0, domainEnd) + HttpUtility.UrlPathEncode(proxyPath.Substring(domainEnd));
}
}
else {
// it doesn't appear to be an absolute url, at least not an http or https one. All relative paths
// and other oddities are safely encoded with UrlPathEncode.
proxyPath = HttpUtility.UrlPathEncode(proxyPath);
}
_builder.Append(typeName).Append(".set_path(\"").Append(proxyPath).Append("\");\r\n");
if (GetSupportsJsonp()) {
_builder.Append(typeName).Append(".set_enableJsonp(true);\r\n");
string jsonpParameterName = GetJsonpCallbackParameterName();
if (!String.IsNullOrEmpty(jsonpParameterName) && !jsonpParameterName.Equals("callback", StringComparison.Ordinal)) {
_builder.Append(typeName).Append(".set_jsonpCallbackParameter(").Append(JavaScriptSerializer.SerializeInternal(jsonpParameterName)).Append(");\r\n");
}
}
}
private void BuildArgsDictionary(WebServiceMethodData methodData, StringBuilder args, StringBuilder argsDict, StringBuilder docComments) {
argsDict.Append('{');
foreach (WebServiceParameterData paramData in methodData.ParameterDatas) {
string name = paramData.ParameterName;
if (docComments != null) {
// looks like: /// <param name="foo" type="ClientType">Namespace.ServerType</param>
// client type may not match server type for built in js types like date, number, etc.
// client type may be omitted for type Object.
docComments.Append("/// <param name=\"").Append(name).Append("\"");
Type serverType = ServicesUtilities.UnwrapNullableType(paramData.ParameterType);
string clientType = GetClientTypeNamespace(ServicesUtilities.GetClientTypeFromServerType(methodData.Owner, serverType));
if (!String.IsNullOrEmpty(clientType)) {
docComments.Append(" type=\"").Append(clientType).Append("\"");
}
docComments.Append(">").Append(serverType.FullName).Append("</param>\r\n");
}
if (args.Length > 0) {
args.Append(',');
argsDict.Append(',');
}
args.Append(name);
argsDict.Append(name).Append(':').Append(name);
}
if (docComments != null) {
// append the built-in comments that all methods have (success, failed, usercontext parameters)
docComments.Append(DebugXmlComments);
}
argsDict.Append("}");
if (args.Length > 0) {
args.Append(',');
}
args.Append("succeededCallback, failedCallback, userContext");
}
private void GenerateWebMethodProxy(WebServiceMethodData methodData) {
string methodName = methodData.MethodName;
string typeName = GetProxyTypeName(methodData.Owner);
string useGet = methodData.UseGet ? "true" : "false";
_builder.Append(methodName).Append(':');
// e.g. MyMethod : function(param1, param2, ..., OnSuccess, OnFailure)
StringBuilder args = new StringBuilder();
StringBuilder argsDict = new StringBuilder();
StringBuilder docComments = null;
string docCommentsString = null;
if (_debugMode) {
docComments = new StringBuilder();
}
BuildArgsDictionary(methodData, args, argsDict, docComments);
if (_debugMode) {
// Remember the doc comments for the static instance case
docCommentsString = docComments.ToString();
_docCommentCache[methodName] = docCommentsString;
}
// Method calls look like this.invoke(FooNS.Sub.Method.get_path(), 'MethodName', true[useGet], {'arg1':'val1', 'arg2':'val2' }, onComplete, onError, userContext, 'FooNS.Sub.Method')
_builder.Append("function(").Append(args.ToString()).Append(") {\r\n");
if (_debugMode) {
// docCommentsString always end in \r\n
_builder.Append(docCommentsString);
}
_builder.Append("return this._invoke(this._get_path(), ");
_builder.Append("'").Append(methodName).Append("',");
_builder.Append(useGet).Append(',');
_builder.Append(argsDict.ToString()).Append(",succeededCallback,failedCallback,userContext); }");
}
/* e.g
var Qqq = function() { this.__type = "Qqq"; }
*/
private void GenerateClientTypeProxies(WebServiceData data) {
bool first = true;
foreach (WebServiceTypeData t in data.ClientTypes) {
if (first) {
_builder.Append("var gtc = Sys.Net.WebServiceProxy._generateTypedConstructor;\r\n");
first = false;
}
string typeID = data.GetTypeStringRepresentation(t);
string typeNameWithClientNamespace = GetClientTypeNamespace(t.TypeName);
string typeName = ServicesUtilities.GetClientTypeName(typeNameWithClientNamespace);
string clientTypeNamespace = GetClientTypeNamespace(t.TypeNamespace);
EnsureNamespace(t.TypeNamespace);
EnsureObjectGraph(clientTypeNamespace, typeName);
_builder.Append("if (typeof(").Append(typeName).Append(") === 'undefined') {\r\n");
AppendClientTypeDeclaration(clientTypeNamespace, typeNameWithClientNamespace, false, false);
// Need to use the _type id, which isn't necessarly the real name
_builder.Append("gtc(\"");
_builder.Append(typeID);
_builder.Append("\");\r\n");
_builder.Append(typeName).Append(".registerClass('").Append(typeName).Append("');\r\n}\r\n");
}
}
// Create client stubs for all the enums
private void GenerateEnumTypeProxies(IEnumerable<WebServiceEnumData> enumTypes) {
foreach (WebServiceEnumData t in enumTypes) {
EnsureNamespace(t.TypeNamespace);
string typeNameWithClientNamespace = GetClientTypeNamespace(t.TypeName);
string typeName = ServicesUtilities.GetClientTypeName(typeNameWithClientNamespace);
string[] enumNames = t.Names;
long[] enumValues = t.Values;
Debug.Assert(enumNames.Length == enumValues.Length);
EnsureObjectGraph(GetClientTypeNamespace(t.TypeNamespace), typeName);
_builder.Append("if (typeof(").Append(typeName).Append(") === 'undefined') {\r\n");
if (typeName.IndexOf('.') == -1) {
_builder.Append("var ");
}
_builder.Append(typeName).Append(" = function() { throw Error.invalidOperation(); }\r\n");
_builder.Append(typeName).Append(".prototype = {");
for (int i = 0; i < enumNames.Length; i++) {
if (i > 0) _builder.Append(',');
_builder.Append(enumNames[i]);
_builder.Append(": ");
if (t.IsULong) {
_builder.Append((ulong)enumValues[i]);
}
else {
_builder.Append(enumValues[i]);
}
}
_builder.Append("}\r\n");
_builder.Append(typeName).Append(".registerEnum('").Append(typeName).Append('\'');
_builder.Append(", true);\r\n}\r\n");
}
}
protected virtual string GetClientTypeNamespace(string ns) {
return ns;
}
private void AppendClientTypeDeclaration(string ns, string typeName, bool genClass, bool ensureNS) {
// Register the namespace if any
// e.g. registerNamespace('MyNS.MySubNS');
string name = GetClientTypeNamespace(ServicesUtilities.GetClientTypeName(typeName));
if (!String.IsNullOrEmpty(ns)) {
if (ensureNS) EnsureNamespace(ns);
}
else if (!genClass) {
// If there is no namespace, we need a var to declare the variable
if (!name.Contains(".")) {
// if name contains '.', an object graph was already ensured and we dont need 'var'.
_builder.Append("var ");
}
}
_builder.Append(name);
if (genClass) {
_builder.Append(".prototype");
}
_builder.Append('=');
_ensuredObjectParts[name] = null;
}
// Normally returns MyNS.MySubNS.MyWebService OR var MyWebService, PageMethods will return PageMethods
protected virtual string GetProxyTypeName(WebServiceData data) {
return ServicesUtilities.GetClientTypeName(data.TypeData.TypeName);
}
private void EnsureNamespace(string ns) {
//Give derived proxy generator a chance to transform namespace ( used by WCF)
ns = GetClientTypeNamespace(ns);
if (String.IsNullOrEmpty(ns)) return;
// Don't register a given namespace more than once
if (!_registeredNamespaces.Contains(ns)) {
_builder.Append("Type.registerNamespace('").Append(ns).Append("');\r\n");
_registeredNamespaces[ns] = null;
}
}
private void EnsureObjectGraph(string namespacePart, string typeName) {
// When a type name includes dots, such as 'MyNamespace.MyClass.MyNestedClass',
// this method writes code that ensures all the parts leading up to the actual class name
// are either already namespaces or are at least Objects.
// namespacePart is here so we dont unnecessarily ensure the first part that contains the
// namespace is checked for. For example, if we have NS1.NS2.NS3.TYPE, the check for
// _registeredNamespaces will find NS1.NS2.NS3 but not NS1 and NS1.NS2, so we'd insert
// checks that NS1 and NS1.NS2 are objects, unnecessarily.
int startFrom = 0;
bool first = true;
if (!String.IsNullOrEmpty(namespacePart)) {
int nsIndex = typeName.IndexOf(namespacePart + ".", StringComparison.Ordinal);
// in wcf services, the typeName starts with the namespace,
// in asmx services, it doesnt.
if (nsIndex > -1) {
startFrom = nsIndex + namespacePart.Length + 1;
first = false;
}
}
int dotIndex = typeName.IndexOf('.', startFrom);
while (dotIndex > -1) {
string fullPath = typeName.Substring(0, dotIndex);
if (!_registeredNamespaces.Contains(fullPath) && !_ensuredObjectParts.Contains(fullPath)) {
_ensuredObjectParts[fullPath] = null;
_builder.Append("if (typeof(" + fullPath + ") === \"undefined\") {\r\n ");
if (first) {
// var foo = {};
_builder.Append("var ");
first = false;
}
// foo.bar = {};
_builder.Append(fullPath + " = {};\r\n}\r\n");
}
dotIndex = typeName.IndexOf('.', dotIndex + 1);
}
}
}
}