Web services wsdl的类型脚本定义

我正在使用asp:ScriptManager从javascript调用我的webmethods。 现在我迁移到TypeScript，希望我的WebMethods和DTO定义可以从TypeScript中使用。我搜索了，但找不到任何（）可以这样做

现在我正在实现一个代码生成工具，它接受wsdl并生成类型脚本类型。完成后，我会在这里分享，但同时，如果您知道任何可以实现这一点的工具，我将很高兴听到

提前谢谢

---

这就是我从javascipt调用webmethods的方式

1） web.config

2） Default.aspx

3） SomeFile.js

SomeMethod（someParameter1，someParameter2，函数（结果）{
警报（“成功：+结果”）；
}，函数（err）{
警报（“错误：+err”）；
});

我可以看到一个js文件，其中包含调用我的Web服务的函数

---

~/MyService.svc/ajax/jsdebug

这是我编写和使用的代码，但是您需要为自己的wsdl更改一些参数。反馈是非常宝贵的

此外，如果有人升级并将其制作成博客文章，我想（我没有博客）很多人都会需要它，我想，这可以节省我们项目和整理东西的大量时间

顺便说一下，我在Linqpad中运行了这段代码。这就是为什么方法不是静态的，在Main（）的最后一行中有一个object.Dump（）调用

void Main（）
{
var svcUrl=”http://localhost:12345/MyService.svc";
var declaration=“declare var MyService:MyServiceClient；”；
var koRef=“//\r\n//”；
TypeScriptWebServiceAndKnockOutTypings（svcUrl、声明、koRef）.Dump（）；
}
字符串类型ScriptWebServiceAndKnockoutTypings（字符串svcUrl、字符串声明、字符串koRef）
{
var outputPath=@“d:\output”；
删除（outputPath+“.cs”）；
Delete（outputPath+“.dll”）；
Process.Start（@“C:\Program Files（x86）\Microsoft SDK\Windows\v8.0A\bin\NETFX 4.0 Tools\x64\svcutil.exe”，“/language:cs/out:“+outputPath+”.cs”+svcUrl）.WaitForExit（）；
Process.Start（@“C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe”，“/t:library/out:“+outputPath+”.dll“+outputPath+”.cs”）.WaitForExit（）；
var a=Assembly.LoadFile（outputPath+“.dll”）；
var sbEnums=新的StringBuilder（）；
var sbClasses=新的StringBuilder（）；
#区域类型转换
var dictTypesNormal=新字典（）；
dictTypesNormal.Add（typeof（Int32），“number”）；
dictTypesNormal.Add（typeof（UInt32），“编号”）；
dictTypesNormal.Add（typeof（Int64），“number”）；
dictTypesNormal.Add（typeof（UInt64），“编号”）；
dictTypesNormal.Add（typeof（float），“number”）；
dictTypesNormal.Add（typeof（double），“number”）；
dictTypesNormal.Add（typeof（bool），“bool”）；
dictTypesNormal.Add（typeof（string），“string”）；
dictTypesNormal.Add（typeof（Object），“any”）；
dictTypesNormal.Add（typeof（DateTime），“Date”）；
var dictTypesKnockout=新字典（）；
添加（typeof（Int32），“knockoutobserveEnumber”）；
dictTypesKnockout.Add（typeof（UInt32），“knockoutobserveenumber”）；
添加（typeof（Int64），“knockoutobserveEnumber”）；
dictTypesKnockout.Add（typeof（UInt64），“knockoutobserveEnumber”）；
dictTypesKnockout.Add（typeof（float），“knockoutobserveEnumber”）；
添加（typeof（double），“knockoutobserveEnumber”）；
添加（typeof（bool），“knockoutobservebool”）；
Add（typeof（string），“knockoutobservestring”）；
添加（typeof（Object），“knockoutobserveany”）；
dictTypesKnockout.Add（typeof（DateTime），“knockoutobservedate”）；
var classNames=a.DefinedTypes.Where（t=>！t.IsEnum）.Select（t=>t.Name.ToList（）；
var enumNames=a.DefinedTypes.Where（t=>t.IsEnum）.Select（t=>t.Name.ToList（）；
#区域获取类型名称
Func getTypeNameNormal=t=>{
if（dictTypesNormal.ContainsKey（t））
返回dictypesnormal[t]；
if（classNames.Contains（t.Name.Replace（“[]”，“”）））
返回t.Name；
if（enumNames.Contains（t.Name.Replace（“[]”，“”）））
返回“Enum”+t.名称；
抛出新异常（string.Format（“未知类型[{0}]”，t.Name））；
};
Func getTypeNameKnockout=t=>{
if（dictTypesKnockout.ContainsKey（t））
返回dictypesknockout[t]；
if（classNames.Contains（t.Name.Replace（“[]”，“”）））
返回t.Name+“\u knockoutmap”；
if（enumNames.Contains（t.Name.Replace（“[]”，“”）））
返回“knockoutobserveEnum”+t.Name+“EnumMember”；
抛出新异常（string.Format（“未知类型[{0}]”，t.Name））；
};
#端区
#区域转换字段
Func convertFieldNormal=null；convertFieldNormal=（pName，f）=>{
//空虚
如果（f==typeof（void））
返回“”；
//排列
如果（f.IsArray）
返回string.Format（“{0}{1}[]”，pName，convertFieldNormal（“，f.GetElementType（））；
//财产
如果（！f.IsGenericType）
返回string.Format（“{0}:{1}”，pName，getTypeNameNormal（f））；
//可空
如果（f.GetGenericTypeDefinition（）==typeof（可为空））
返回string.Format（“{0}:{1}”，pName，getTypeNameNormal（f.GetGenericArguments（）[0]）；
//字典
如果（f.GetGenericTypeDefinition（）.ToString（）包含（“字典”））
返回string.Format（“{0}:{{{1}；{2}；}}[]”，pName，convertFieldNormal（“Key”，f.GetGenericArguments（）[0]），convertFieldNormal（“Value”，f.GetGenericArguments（）[1]）；
抛出新异常（string.Format（“属性{1}的未知泛型类型[{0}]，f.Name，pName））；
};
Func convertFieldKnockout=null；convertFieldKnockout=（pName，f）=>{
//空虚
如果（f==typeof（void））
返回“”；
//排列
如果（f.IsArray）
返回s
<system.serviceModel>
<services>
  <service name="Services.MyService" behaviorConfiguration="metadataBehavior">
    <endpoint binding="basicHttpBinding" contract="Services.MyService"/>
    <endpoint address="/ajax" behaviorConfiguration="Services.MyServiceAspNetAjaxBehavior" binding="webHttpBinding" contract="Services.MyService"/>
  </service>
</services>
<behaviors>
  <endpointBehaviors>
    <behavior name="Services.MyServiceAspNetAjaxBehavior">
      <enableWebScript />
    </behavior>
  </endpointBehaviors>
</behaviors>
</system.serviceModel>

<form id="form1" runat="server">
    <asp:ScriptManager ID="Scriptmanager1" runat="server">
        <Services>
            <asp:ServiceReference Path="~/MyService.svc/ajax" />
        </Services>
    </asp:ScriptManager>
</form>

<script>
    MyService.SomeMethod(someParameter1, someParameter2, function(result) {
        alert("Success: " + result);
    }, function(err){
        alert("Error: " + err);
    });

</script>

void Main()
{
    var svcUrl = "http://localhost:12345/MyService.svc";
    var declaration = "declare var MyService: MyServiceClient;";
    var koRef = "/// <reference path=\"../../Scripts/typings/knockout.mapping/knockout.mapping.d.ts" +
    "\" />\r\n/// <reference path=\"../../Scripts/typings/knockout/knockout.d.ts\" />";


    TypeScriptWebServiceAndKnockOutTypings(svcUrl, declaration, koRef).Dump();
}


string TypeScriptWebServiceAndKnockOutTypings(string svcUrl, string declaration, string koRef)
{
    var outputPath = @"d:\output";

    File.Delete(outputPath + ".cs");
    File.Delete(outputPath + ".dll");
    Process.Start(@"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools\x64\svcutil.exe",  " /language:cs /out:" + outputPath + ".cs " + svcUrl).WaitForExit();
    Process.Start(@"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe", " /t:library /out:"+ outputPath + ".dll  "+ outputPath + ".cs").WaitForExit();

    var a = Assembly.LoadFile(outputPath + ".dll");

    var sbEnums = new StringBuilder();
    var sbClasses = new StringBuilder();

    #region types conversions

    var dictTypesNormal = new Dictionary<Type, string>();
    dictTypesNormal.Add(typeof(Int32), "number");
    dictTypesNormal.Add(typeof(UInt32), "number");
    dictTypesNormal.Add(typeof(Int64), "number");
    dictTypesNormal.Add(typeof(UInt64), "number");
    dictTypesNormal.Add(typeof(float), "number");
    dictTypesNormal.Add(typeof(double), "number");
    dictTypesNormal.Add(typeof(bool), "bool");
    dictTypesNormal.Add(typeof(string), "string");
    dictTypesNormal.Add(typeof(Object), "any");
    dictTypesNormal.Add(typeof(DateTime), "Date");

    var dictTypesKnockout = new Dictionary<Type, string>();
    dictTypesKnockout.Add(typeof(Int32), "KnockoutObservableNumber");
    dictTypesKnockout.Add(typeof(UInt32), "KnockoutObservableNumber");
    dictTypesKnockout.Add(typeof(Int64), "KnockoutObservableNumber");
    dictTypesKnockout.Add(typeof(UInt64), "KnockoutObservableNumber");
    dictTypesKnockout.Add(typeof(float), "KnockoutObservableNumber");
    dictTypesKnockout.Add(typeof(double), "KnockoutObservableNumber");
    dictTypesKnockout.Add(typeof(bool), "KnockoutObservableBool");
    dictTypesKnockout.Add(typeof(string), "KnockoutObservableString");
    dictTypesKnockout.Add(typeof(Object), "KnockoutObservableAny");
    dictTypesKnockout.Add(typeof(DateTime), "KnockoutObservableDate");

    var classNames = a.DefinedTypes.Where(t => !t.IsEnum).Select(t=>t.Name).ToList();
    var enumNames = a.DefinedTypes.Where(t => t.IsEnum).Select(t=>t.Name).ToList();

    #region get type name

    Func<Type, string> getTypeNameNormal = t => {
        if(dictTypesNormal.ContainsKey(t)) 
            return dictTypesNormal[t];

        if(classNames.Contains(t.Name.Replace("[]", ""))) 
            return t.Name;

        if(enumNames.Contains(t.Name.Replace("[]", ""))) 
            return "Enum" + t.Name;

        throw new Exception(string.Format("Unknown type [{0}]", t.Name));
    };

    Func<Type, string> getTypeNameKnockout = t => {
        if(dictTypesKnockout.ContainsKey(t)) 
            return dictTypesKnockout[t];

        if(classNames.Contains(t.Name.Replace("[]", ""))) 
            return t.Name + "_KnockoutMapped";

        if(enumNames.Contains(t.Name.Replace("[]", ""))) 
            return "KnockoutObservableEnum" + t.Name + "EnumMember";

        throw new Exception(string.Format("Unknown type [{0}]", t.Name));
    };

    #endregion

    #region convert field 

    Func<string, Type, string> convertFieldNormal = null; convertFieldNormal = (pName, f) => {

        // void
        if(f == typeof(void)) 
            return "";

        // array
        if(f.IsArray)
            return string.Format("{0}{1}[]", pName, convertFieldNormal("", f.GetElementType()));

        // property
        if(!f.IsGenericType) 
            return string.Format("{0}: {1}", pName, getTypeNameNormal(f));

        // nullable
        if(f.GetGenericTypeDefinition() == typeof(Nullable<>)) 
            return string.Format("{0}: {1}", pName, getTypeNameNormal(f.GetGenericArguments()[0]));

        // dictionaries
        if(f.GetGenericTypeDefinition().ToString().Contains("Dictionary")) 
            return string.Format("{0}: {{ {1}; {2}; }}[]", pName, convertFieldNormal("Key", f.GetGenericArguments()[0]), convertFieldNormal("Value", f.GetGenericArguments()[1]));

        throw new Exception(string.Format("Unknown generic type [{0}] for property {1}", f.Name, pName));
    };

    Func<string, Type, string> convertFieldKnockout = null; convertFieldKnockout = (pName, f) => {

        // void
        if(f == typeof(void)) 
            return "";

        // array
        if(f.IsArray)
            return string.Format("{0}{1}[]", pName, convertFieldKnockout("", f.GetElementType()));

        // property
        if(!f.IsGenericType) 
            return string.Format("{0}: {1}", pName, getTypeNameKnockout(f));

        // nullable
        if(f.GetGenericTypeDefinition() == typeof(Nullable<>)) 
            return string.Format("{0}: {1}", pName, getTypeNameKnockout(f.GetGenericArguments()[0]));

        // dictionaries
        if(f.GetGenericTypeDefinition().ToString().Contains("Dictionary")) 
            return string.Format("{0}: {{ {1}; {2}; }}[]", pName, convertFieldKnockout("Key", f.GetGenericArguments()[0]), convertFieldKnockout("Value", f.GetGenericArguments()[1]));

        throw new Exception(string.Format("Unknown generic type [{0}] for property {1}", f.Name, pName));
    };

    #endregion

    #endregion

    #region enums

    foreach (var e in a.DefinedTypes.Where(t => t.IsEnum))
    {
        #region enum definition
        sbEnums.AppendLine(string.Format("enum Enum{0} {{", e.Name));

        sbEnums.AppendLine(string.Format("\t{0} = {1},", "Tümü", -1)); 

        foreach (var v in Enum.GetValues(e))
        {
            sbEnums.AppendLine(string.Format("\t{0} = {1},", v.ToString(), (int)v)); 
        }

        sbEnums.AppendLine("}");
        #endregion

        #region knockout

        sbEnums.AppendLine(string.Format(
            @"interface KnockoutObservable{0} extends KnockoutObservableBase {{
                (): {0};
                (value: {0}): void;

                subscribe(callback: (newValue: {0}) => void , target?: any, topic?: string): KnockoutSubscription;
                notifySubscribers(valueToWrite: {0}, topic?: string);
            }}", "Enum" + e.Name + "EnumMember"));

        #endregion

        #region enum member

        sbEnums.AppendLine(string.Format(
            @"class Enum{0}EnumMember {{
                constructor(public Key: Enum{0}, public Value: string) {{ }};
                public toString() {{ return this.Value }};
              }}", e.Name));

        #endregion

        #region combobox definition
        sbEnums.AppendLine(string.Format("var {0}s: Enum{0}EnumMember[] = [", e.Name));

        sbEnums.AppendLine(string.Format("\t new Enum{0}EnumMember(Enum{0}.{1}, \"{1}\"),", e.Name, "Tümü")); 

        foreach (var v in Enum.GetValues(e))
        {
            sbEnums.AppendLine(string.Format("\t new Enum{0}EnumMember(Enum{0}.{1}, \"{1}\"),", e.Name, v.ToString())); 
        }

        sbEnums.AppendLine("];");
        #endregion

        //public OnayDurumlari = ko.observable([{ Key: 3, Value: "Tümü" }, { Key: 0, Value: "Onay Bekliyor" }, { Key: 1, Value: "Onaylı" }, { Key: 2, Value: "Red" }]); 

        sbEnums.AppendLine();
    }

    #endregion

    #region classes

    #region find classes & methods

    var classes =  (from t in a.DefinedTypes
                    where t.IsEnum == false
                    let methods = (from m in t.GetMethods()
                                    where !m.IsSpecialName 
                                    && m.IsFinal 
                                    && m.IsVirtual 
                                    && m.IsHideBySig 
                                    && m.IsSecurityCritical 
                                    && !m.Name.EndsWith("Async")
                                    select m)
                    where t.DeclaredProperties.Any()
                        || methods.Any()
                    select new
                    {
                        t.Name,
                        t.DeclaredProperties,
                        methods,
                    });

    #endregion

    foreach (var t in classes)
    {
        #region interface definition

        sbClasses.AppendLine(string.Format("{1} {0} {{", t.Name, t.DeclaredProperties.Any() ? "class" : "interface"));

        foreach (var p in t.DeclaredProperties)
        {
            if(p.Name == "ExtensionData") continue;
            var f = p.GetGetMethod().ReturnType;

            sbClasses.AppendLine(string.Format("\t{0};", convertFieldNormal(p.Name, f)));
        }

        #region methods

        foreach (var m in t.methods)
        {
            sbClasses.AppendLine(string.Format("\t{0}({1}Success: ({2}) => void, Fail?: (err: Sys$Net$WebServiceError) => void ) : void;", 
                m.Name, 
                string.Concat(m.GetParameters().Select(p => convertFieldNormal(p.Name, p.ParameterType) + ", ")),
                convertFieldNormal("result", m.ReturnType)));
        }

        #endregion

        sbClasses.AppendLine("}");

        #endregion

        #region knockout

        if(t.DeclaredProperties.Any())
        {
            sbClasses.AppendLine(string.Format(@"
                interface KnockoutObservable{0} extends KnockoutObservableBase {{
                    (): {0};
                    (value: {0}): void;

                    subscribe(callback: (newValue: {0}) => void , target?: any, topic?: string): KnockoutSubscription;
                    notifySubscribers(valueToWrite: {0}, topic?: string);
                }}", t.Name));
//  
//          sbClasses.AppendLine(string.Format(@"
//              interface KnockoutObservableStatic {{
//                  (value: {0}): KnockoutObservable{0};
//                  new (value: {0}): KnockoutObservable{0};
//              }}", t.Name));

            #region KnockoutObservableArray

            sbClasses.AppendLine(string.Format(
                @"interface {0}_KnockoutObservableArray extends KnockoutObservableArrayFunctions {{
                    (): {0}_KnockoutMapped[];
                    (value: {0}_KnockoutMapped[]): void;

                    subscribe(callback: (newValue: {0}_KnockoutMapped[]) => void, target?:any, topic?: string): KnockoutSubscription;
                    notifySubscribers(valueToWrite: {0}_KnockoutMapped[], topic?: string);
                }}", t.Name));

            #endregion

            #region _KnockoutMapped
            sbClasses.AppendLine(string.Format("interface {0}_KnockoutMapped {{", t.Name));

            foreach (var p in t.DeclaredProperties)
            {
                if(p.Name == "ExtensionData") continue;
                var f = p.GetGetMethod().ReturnType;

                sbClasses.AppendLine(string.Format("\t{0};", convertFieldKnockout(p.Name, f)));
            }               
            sbClasses.AppendLine("}");
            #endregion

        }
        #endregion

        sbClasses.AppendLine();
    }

    #endregion

    #region knockout

    var sbKnockout = new StringBuilder();

    #region mapper
    sbKnockout.AppendLine("module Mapper {");
    classes.Where(c=>c.DeclaredProperties.Any()).ToList().ForEach(c=>{
        sbKnockout.AppendLine(string.Format("\texport function fromJs_{0}(r : {0}) : {0}_KnockoutMapped {{return ko.mapping.fromJS(r);}}", c.Name));
        sbKnockout.AppendLine(string.Format("\texport function toJs_{0}(r : {0}_KnockoutMapped) : {0} {{return ko.mapping.toJS(r);}}", c.Name));
        sbKnockout.AppendLine(string.Format("\texport function fromJsArray_{0}(r : {0}[]) : {0}_KnockoutMapped[] {{return r.map(k => ko.mapping.fromJS(k));}}", c.Name));
        sbKnockout.AppendLine(string.Format("\texport function toJsArray_{0}(r : {0}_KnockoutMapped[]) : {0}[] {{return r.map(k => ko.mapping.toJS(k));}}", c.Name));
    });
    sbKnockout.AppendLine("}");
    sbKnockout.AppendLine();
    #endregion

    #region knockout definitions
    sbKnockout.AppendLine("declare var ko;");
    dictTypesKnockout.Select(k=>k.Value).Distinct().ToList().ForEach(k=>{
        sbKnockout.AppendLine(string.Format("interface {0} {{}}", k));
    });
    sbKnockout.AppendLine("interface KnockoutSubscription {}");
    sbKnockout.AppendLine("interface KnockoutObservableArrayFunctions {}");
    sbKnockout.AppendLine();
    #endregion

    #endregion

    return koRef 
         + "interface Sys$Net$WebServiceError {_timedOut: bool;_message: string;_stackTrace: string;_exceptionType: string;_errorObject: {ExceptionDetail: {HelpLink: any; InnerException: any; Message: string; StackTrace: string;Type: string;};ExceptionType: string;Message: string;StackTrace: string;};}\r\n\r\n"
         + sbEnums.ToString()
         + sbClasses.ToString()
         + sbKnockout
         + declaration;
}