วิธีการนำนิยามคลาส C # ที่มีอยู่กลับมาใช้ใหม่ในโปรเจ็กต์ TypeScript

ฉันจะเริ่มใช้TypeScriptในโปรเจ็กต์ไคลเอนต์ HTML ของฉันซึ่งเป็นของโครงการ MVC ที่มีโมเดลโดเมนเฟรมเวิร์กเอนทิตีอยู่แล้ว ฉันต้องการให้สองโปรเจ็กต์ของฉัน (ฝั่งไคลเอ็นต์และฝั่งเซิร์ฟเวอร์) แยกออกจากกันโดยสิ้นเชิงเนื่องจากทั้งสองทีมจะทำงานกับสิ่งนี้ ... JSON และ REST ใช้เพื่อสื่อสารอ็อบเจกต์ไปมา

แน่นอนว่าdomainวัตถุของฉันในฝั่งไคลเอ็นต์ควรตรงกับวัตถุทางฝั่งเซิร์ฟเวอร์ ที่ผ่านมาฉันทำสิ่งนี้ด้วยตนเองเป็นปกติ มีวิธีการนำนิยามคลาส C # ของฉันกลับมาใช้ซ้ำ (โดยเฉพาะของPOJOคลาสในโมเดลโดเมนของฉัน) เพื่อสร้างคลาสที่สอดคล้องกันใน TypeScript "หรือไม่

ขณะนี้ยังไม่มีสิ่งใดที่จะแมป C # กับ TypeScript หากคุณมี POCO จำนวนมากหรือคุณคิดว่าอาจมีการเปลี่ยนแปลงบ่อยๆคุณสามารถสร้างตัวแปลง - สิ่งง่ายๆตามแนว ...

public class MyPoco {
    public string Name { get; set; }
}

ถึง

export class MyPoco {
    public Name: string;
}

นอกจากนี้ยังมีการอภิปรายเกี่ยวกับ Codeplex เกี่ยวกับรถยนต์ที่ก่อจาก C #

เพื่อให้สิ่งต่าง ๆ อัปเดต TypeLite สามารถสร้างอินเตอร์เฟส TypeScript จาก C #:

http://type.litesolutions.net/

Web Essentialsอนุญาตให้คอมไพล์ไฟล์ C # เป็นไฟล์ TypeScript .d.tsเมื่อบันทึก จากนั้นคุณสามารถอ้างอิงคำจำกัดความจาก.tsไฟล์ของคุณ

TypeLite และ T4TS ด้านบนทั้งคู่ดูดีเพียงแค่เลือกหนึ่ง TypeLite แยกมันเพื่อรับการสนับสนุนสำหรับ

• ValueTypes ,
• Nullables
• camelCasing (TypeScript root doc ใช้อูฐและสิ่งนี้ก็เข้ากันได้ดีกับ C #)
• ฟิลด์สาธารณะ (รัก POCO ที่สะอาดและอ่านง่ายยังช่วยให้คอมไพเลอร์ C # เป็นเรื่องง่าย)
• ปิดใช้งานการสร้างโมดูล

จากนั้นฉันก็ต้องการอินเทอร์เฟซ C # และคิดว่าถึงเวลาที่ต้องอบสิ่งของของตัวเองและเขียนสคริปต์ T4 ง่ายๆที่ทำในสิ่งที่ฉันต้องการ นอกจากนี้ยังรวมถึงEnums Enumsไม่จำเป็นต้องใช้ repo เพียง <100 บรรทัดของ T4

การใช้งาน
ไม่มีไลบรารีไม่มี NuGet เพียงแค่ไฟล์ T4 ธรรมดา ๆ นี้ - ใช้ "เพิ่มรายการ" ใน Visual Studio และเลือกเทมเพลต T4 ใดก็ได้ จากนั้นวางลงในไฟล์ ปรับทุกบรรทัดด้วย "ACME" ในนั้น สำหรับทุกชั้น C # เพิ่มบรรทัด

<#= Interface<Acme.Duck>() #>

การสั่งซื้อมีความสำคัญประเภทใด ๆ ที่รู้จักจะถูกใช้ในอินเตอร์เฟส follwing หากคุณใช้เฉพาะอินเทอร์เฟซนามสกุลไฟล์อาจเป็น. d.tsสำหรับ enums คุณต้องมีไฟล์. tsเนื่องจากตัวแปรถูกสร้างอินสแตนซ์

การปรับแต่ง
แฮ็คสคริปต์

<#@ template debug="true" hostSpecific="true" language="C#" #>
<#@ output extension=".ts" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ assembly name="$(TargetDir)ACME.Core.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Linq" #>

<#= Interface<Acme.Bunny>() #>
<#= Interface<Acme.Duck>() #>
<#= Interface<Acme.Birdy>() #>
<#= Enums<Acme.CarrotGrade>() #>
<#= Interface<Acme.LinkParticle>() #>

<#+  
    List<Type> knownTypes = new List<Type>();

    string Interface<T>()
    {   
        Type t = typeof(T);     
        var sb = new StringBuilder();
        sb.AppendFormat("interface {0} {{\n", t.Name);
        foreach (var mi in GetInterfaceMembers(t))
        {
            sb.AppendFormat("  {0}: {1};\n", this.ToCamelCase(mi.Name), GetTypeName(mi));
        }
        sb.AppendLine("}");
        knownTypes.Add(t);
        return sb.ToString();
    }

    IEnumerable<MemberInfo> GetInterfaceMembers(Type type)
    {
        return type.GetMembers(BindingFlags.Public | BindingFlags.Instance)
            .Where(mi => mi.MemberType == MemberTypes.Field || mi.MemberType == MemberTypes.Property);
    }

    string ToCamelCase(string s)
    {
        if (string.IsNullOrEmpty(s)) return s;
        if (s.Length < 2) return s.ToLowerInvariant();
        return char.ToLowerInvariant(s[0]) + s.Substring(1);
    }

    string GetTypeName(MemberInfo mi)
    {
        Type t = (mi is PropertyInfo) ? ((PropertyInfo)mi).PropertyType : ((FieldInfo)mi).FieldType;
        return this.GetTypeName(t);
    }

    string GetTypeName(Type t)
    {
        if(t.IsPrimitive)
        {
            if (t == typeof(bool)) return "bool";
            if (t == typeof(char)) return "string";
            return "number";
        }
        if (t == typeof(decimal)) return "number";            
        if (t == typeof(string)) return "string";
        if (t.IsArray)
        {            
            var at = t.GetElementType();
            return this.GetTypeName(at) + "[]";
        }
        if(typeof (System.Collections.IEnumerable).IsAssignableFrom(t)) 
        {
            var collectionType = t.GetGenericArguments()[0]; // all my enumerables are typed, so there is a generic argument
            return GetTypeName(collectionType) + "[]";
        }            
        if (Nullable.GetUnderlyingType(t) != null)
        {
            return this.GetTypeName(Nullable.GetUnderlyingType(t));
        }
        if(t.IsEnum) return "number";
        if(knownTypes.Contains(t)) return t.Name;
        return "any";
    }

    string Enums<T>() // Enums<>, since Enum<> is not allowed.
    {
        Type t = typeof(T);        
        var sb = new StringBuilder();        
        int[] values = (int[])Enum.GetValues(t);
        sb.AppendLine("var " + t.Name + " = {");
        foreach(var val in values) 
        {
            var name = Enum.GetName(typeof(T), val);
            sb.AppendFormat("{0}: {1},\n", name, val);
        }
        sb.AppendLine("}");
        return sb.ToString();
    }
#>

ระดับถัดไปของสคริปต์คือการสร้างส่วนต่อประสานบริการจากคลาส MVC JsonController

หากคุณใช้ vscode คุณสามารถใช้csharp2tsส่วนขยายของฉันซึ่งทำอย่างนั้นได้

คุณเพียงแค่เลือกรหัส C # ที่วางและเรียกใช้Convert C# to TypeScriptคำสั่งจากชุดคำสั่ง ตัวอย่างการแปลง:

public class Person
{
    /// <summary>
    /// Primary key
    /// </summary>
    public int Id { get; set; }

    /// <summary>
    /// Person name
    /// </summary>
    public string Name { get; set; }
}

ถึง

export interface Person
{
    /**Primary key */
    Id : number;

    /**Person name */
    Name : string;
}

หากคุณใช้ Visual Studio ให้เพิ่มส่วนขยายเครื่องพิมพ์ดีด

แกลเลอรี Visual Studio

เว็บไซต์ / เอกสาร

ปรับปรุง

เมื่อติดตั้งWeb Essentialsใน VS 2015 คุณสามารถคลิกขวาที่ไฟล์คลาสจากนั้น> Web Essentials> สร้างไฟล์ typescript Intellisense จากเมนูบริบท

นี่คือแนวทางของฉันในการแก้ปัญหา ประกาศคลาส C # ของคุณด้วยแอตทริบิวต์และไฟล์. d.ts จะถูกสร้างขึ้น (โดยใช้การแปลง T4) มีเป็นแพคเกจใน nugetและแหล่งที่มาที่มีอยู่บน GitHub ฉันยังคงทำงานในโครงการนี้ แต่การสนับสนุนค่อนข้างครอบคลุม

ลอง Reinforced.Typings framework ดูเหมือนว่าจะช่วยแก้ปัญหาของคุณได้

1. ติดตั้งจากNuGet

2. ไปที่ POCO ของคุณและเพิ่ม[TsInterface]แอตทริบิวต์ด้านบน

   using Reinforced.Typings.Attributes;
   namespace YourNamespace {
       [TsInterface]
       public class YourPoco
       {
           public int YourNumber { get;set; }
           public string YourString { get;set; }
           public List<string> YourArray { get;set; }
           public Dictionary<int, object> YourDictionary { get;set; }
       }
   }

3. สร้างโครงการของคุณใหม่

4. ค้นหารหัส TypeScript ที่สร้างขึ้นใน%Your_Project_Directory%/Scripts/project.tsไฟล์และเพิ่มลงในโครงการด้วยตนเอง

   module YourNamespace {
       export interface IYourPoco
       {
           YourNumber: number;
           YourString: string;
           YourArray: string[];
           YourDictionary: { [key: int]: any };
       }
   }

5. ทำเช่นเดียวกันสำหรับproject.tsPOCO ทั้งหมดของคุณและการอ้างอิงในรหัส TypeScript อื่น ๆ ของคุณ

ดูรายละเอียดเพิ่มเติมในเอกสารวิกิ

ฉันได้สร้างยูทิลิตี้ขนาดเล็กที่สามารถสร้างอินเตอร์เฟส TypeScript จากคลาส C # สามารถใช้ได้เป็นแพคเกจ NuGet เอกสารรายละเอียดที่สามารถพบได้บนหน้าเว็บโครงการ

โปรดดูที่เครื่องพิมพ์ดีดห้องสมุดนี้

ไม่เพียงแปลงคลาส enums อินเทอร์เฟซและอื่น ๆ แต่ยังรวมถึงตัวควบคุม api ซึ่งยอดเยี่ยมมาก ..

นอกจากนี้ยังทำได้ทันทีที่คุณบันทึกไฟล์. cs ต้นทางดังนั้นฉันจึงไม่ต้องทริกเกอร์เครื่องมือภายนอกใด ๆ บันทึก. cs และคุณจะได้รับการปรับปรุง. ts

ฉันมีวิธีแก้ปัญหาเล็กน้อยที่ใช้เทมเพลต T4 ( ดูแหล่งที่มา )

คุณไปจาก CLR POCO ใด ๆ :

public class Parent : Person
{
    public string Name { get; set; }
    public bool? IsGoodParent { get; set; }
    public virtual ICollection<Child> Children { get; set; }
}

ไปยังอินเทอร์เฟซ TypeScript:

///<reference path="Child.d.ts" />
///<reference path="Person.d.ts" />
interface Parent extends Person {
    Name : string;
    IsGoodParent? : bool;
    Children : Child[];
}

คุณสามารถใช้NSwagโปรเจ็กต์โอเพนซอร์สได้ : ใน GUI คุณสามารถเลือกคลาส. NET จาก. NET DLL ที่มีอยู่และสร้างอินเทอร์เฟซ TypeScript สำหรับมัน

โครงการนี้ยังมีเครื่องมือบรรทัดคำสั่งและการสนับสนุนเทมเพลต T4 ตลอดจนการสร้างรหัสไคลเอนต์สำหรับตัวควบคุม Web API ...

หากคุณจำเป็นต้องสร้างไฟล์ที่แยกต่างหากสำหรับทุกสร้าง typescript ระดับ / อินเตอร์เฟซ (เช่นใน "ชั้นเดียวต่อไฟล์" ลักษณะ) คุณสามารถลองTypeGen เป็นเครื่องมือที่คุณสามารถใช้จาก Package Manager Console เพื่อสร้างไฟล์ TypeScript ตาม C # คลาส / enums ของคุณ ปัจจุบันรองรับ:

• การส่งออก enums; การส่งออก POCO เป็นคลาส TS หรืออินเทอร์เฟซ
• มรดก
• ประเภททั่วไป
• คอลเลกชัน / ประเภทคอลเลกชันที่ซ้อนกัน

พร้อมคุณสมบัติเพิ่มเติมบางอย่าง นอกจากนี้ยังเป็นโอเพนซอร์ส (คุณสามารถตรวจสอบได้จากgithub )

แล้วทางอื่นล่ะ?

ตรวจสอบerecruit TypeScript Translatorนักแปล มันมาพร้อมกับการรองรับ C # ที่พร้อมใช้งาน แต่จริงๆแล้วเป็นแบบเทมเพลต (ใช้ Nunjucks ในการเรนเดอร์) ซึ่งหมายความว่ามันสามารถสร้างสิ่งอื่นได้ - VB.NET, F #, C ++, XML, SQL - อะไรก็ตามที่คุณสามารถเข้ารหัสด้วยเทมเพลต

ทำงานเป็นโปรแกรมคอนโซล. NET, โปรแกรม NodeJS (สำหรับผู้ที่ไม่ได้ใช้ Windows) หรือเป็นส่วนขยาย Visual Studioพร้อมด้วยฟังก์ชันการสร้างเมื่อบันทึก และรวมถึงการสนับสนุน MSBuild เพียงเพื่อให้บิลด์เซิร์ฟเวอร์ของคุณมีความสุข :-)

คุณยังสามารถใช้สิ่งนี้: https://github.com/pankleks/TypeScriptBuilder

ไลบรารีขนาดเล็กนี้สร้างนิยามประเภท TypeScript ตามประเภท C # ใช้โดยตรงในโปรเจ็กต์ C # แบ็กเอนด์ของคุณเพื่อสร้างโค้ดสำหรับโปรเจ็กต์ TypeScript ส่วนหน้าของคุณ คุณยังสามารถเขียนแอปคอนโซลขนาดเล็กเพื่อสร้างโค้ดโดยใช้เครื่องมือสร้างล่วงหน้า

ทำงานบนเฟรมเวิร์ก Full & NET Core!

ติดตั้งโดย nuget: Install-Package TypeScriptBuilder

คุณสมบัติที่รองรับ

• การแก้ไขการพึ่งพาประเภท
• generics
• ประเภทการสืบทอด
• เนมสเปซ (โมดูล)
• enums
• ประเภท Nullable
• การแปลงพจนานุกรม (ไปยังวัตถุที่จัดทำดัชนี TS ประเภทที่แข็งแกร่ง)
• ชุดแอตทริบิวต์การควบคุมการสร้างรหัส
• any สำหรับประเภทที่ไม่สามารถแปลงได้

คำอธิบายเพิ่มเติม: https://github.com/pankleks/TypeScriptBuilder/blob/master/README.md

Guys ดูได้ที่https://github.com/reinforced/ Reinforced.Typings Reinforced.Typingsฉันเล่นกับเทมเพลต typelite และ t4 ในช่วงสองสามวันที่ผ่านมาและจบลงด้วยโครงการนี้ มันง่ายมากและใช้งานได้เหมือนมีเสน่ห์ เพียงแค่รับแพ็คเกจแก้ไขไฟล์คอนฟิกูเรชัน (ใช้เวลา 10 วินาที) และสร้าง ทั้งหมดทำได้โดยอัตโนมัติโดยไม่มีปัญหาใด ๆ อวยพรผู้เขียน!

สิ่งที่แย่เกี่ยวกับเทมเพลต T4 คือเมื่อคุณสร้างจาก VS แล้วแอสเซมบลีที่สแกนจะถูกล็อคและคุณต้องรีสตาร์ท VS (โง่แค่ไหน?) มีวิธีแก้ปัญหาบางอย่างใน T4 Toolbox + คำสั่งการทำความสะอาด VS แต่ไม่มีวิธีใดที่ใช้ได้ผลสำหรับฉัน

ฉันชอบการแก้ปัญหาของ citykid ฉันได้ขยายมันออกไปเล็กน้อย ดังนั้นการแก้ปัญหายังขึ้นอยู่กับเทคนิคการสร้างโค้ดด้วยเทมเพลต T4

สามารถสร้างประเภท TypeScript ทั่วไปและการประกาศโดยรอบ

สนับสนุนการสืบทอดและการใช้งานอินเทอร์เฟซ

รองรับ generics อาร์เรย์และรายการเป็นฟิลด์ประเภท

นอกจากนี้ยังแปลเป็นประเภท TypeScript ที่ไม่ได้กล่าวถึงอย่างชัดเจนในการกำหนดค่า (ตัวอย่างเช่นเรานำเข้าประเภท A และในเอาต์พุต TS คุณจะพบประเภทอื่น ๆ ได้แก่ ประเภทของฟิลด์ประเภทฐานและอินเทอร์เฟซ)

คุณยังสามารถแทนที่ชื่อประเภทได้

นอกจากนี้ยังรองรับ Enums

ตัวอย่างการใช้งาน (คุณสามารถค้นหาได้ในที่เก็บโครงการ):

// set extension of the generated TS file
<#@ output extension=".d.ts" #>

// choose the type of TS import TsMode.Ambient || TsMode.Class
<# var tsBuilder = new TsBuilder(TsMode.Ambient); #>

// reference assembly with the c# types to be transformed
<#@ assembly name="$(SolutionDir)artifacts\...\CsT4Ts.Tests.dll" #>

// reference namespaces
<#@ import namespace="CsT4Ts.Tests" #>
<#
    //add types to processing
    tsBuilder.ConsiderType(typeof(PresetDTOBase), "PresetBase");
    tsBuilder.ConsiderType(typeof(PresetDTO), "Preset");
    tsBuilder.ConsiderType(typeof(TestInterface<,>));
#>

// include file with transformation algorithms
<#@ include file="CsT4Ts.t4" #>

และคุณจะได้ผลลัพธ์

//CsT4Ts.Tests.PresetDTOBase => PresetBase
// CsT4Ts.Tests.PresetDTO => Preset
// CsT4Ts.Tests.TestInterface`2 => TestInterface
// CsT4Ts.Tests.TestEnum => TestEnum

declare class PresetBase
{
    PresetId: string;
    Title: string;
    InterviewDate: string;
}

declare class Preset extends PresetBase
{
    QuestionsIds: string[];
}

declare interface TestInterface<TA, TB>
{
    A: string;
    B: number;
    C: TestEnum;
    D: TestEnum[];
    E: number[];
    F: TA;
    G: TB[];
}

declare enum TestEnum
{
    Foo = 10,
    Boo = 100
}

ตรวจสอบโซลูชันฉบับเต็มได้ที่นี่: https://bitbucket.org/chandrush/cst4ts

คุณยังสามารถใช้ Bridge.net จากเวอร์ชัน 1.7 รองรับการสร้างคำจำกัดความ TypeScript สำหรับประเภท C # ดูhttp://bridge.net/docs/generate-typescript-definitions/

ฉันชอบคำตอบของ @ citykid เป็นอย่างมากดังนั้นฉันจึงขยายเพื่อทำเนมสเปซทั้งหมดในแต่ละครั้ง เพียงใส่คลาส POCO ลงในเนมสเปซและสร้างเทมเพลต T4 ขึ้นมาใหม่ ฉันหวังว่าฉันจะรู้วิธีสร้างไฟล์แยกกันสำหรับแต่ละไฟล์ แต่นั่นไม่ใช่จุดจบของโลก

คุณต้องอ้างอิงไฟล์. DLL ในส่วนบนสุด (ซึ่งเป็นคลาสที่คุณต้องการ) และคุณต้องพูดถึงเนมสเปซ ทุกบรรทัดที่จะแก้ไขมีเครื่องหมาย ACME ขอขอบคุณที่ @citykid ขอขอบคุณ!

<#@ template debug="true" hostSpecific="true" language="C#" #>
<#@ output extension=".ts" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ assembly name="$(TargetDir)YOUR_DLL_NAME_HERE_ACME.dll" #>
<#@ assembly name="$(TargetDir)YOUR_OTHER_DLL_NAME_HERE_ACME.dll" #>
<#@ assembly name="$(TargetDir)YOUR_OTHER_DLL_NAME_HERE_ACME.dll" #>
<#@ assembly name="$(TargetDir)YOUR_OTHER_DLL_NAME_HERE_ACME.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Reflection" #>

<#= Process("My.Very.Special.Namespace.ACME") #>
<#= Process("My.Other.Very.Special.Namespace.ACME") #>
<#= Process("My.Other.Very.Special.Namespace.ACME") #>
<#= Process("My.Other.Very.Special.Namespace.ACME") #>

<#+  

    List<Type> knownTypes = new List<Type>();

    string Process(string nameSpace) {
      var allass = AppDomain.CurrentDomain.GetAssemblies();
      var ss = "";
      foreach (var ass in allass)
      {
         ss += ProcessAssembly(ass, nameSpace);
      }
      return ss;
    }

   string ProcessAssembly(Assembly asm, string nameSpace) {
      try {
            Type[] types;
            try
            {
                types = asm.GetTypes();
            }
            catch (ReflectionTypeLoadException e)
            {
                types = e.Types;
            }
            var s = "";
            foreach (var t in types.Where(t => t != null))
            {
               try {

               if (String.Equals(t.Namespace, nameSpace, StringComparison.Ordinal))
               {
                    s += InterfaceOfType(t);
               }

               } catch (Exception e)
               {
               }
            }
            return s;      
      }
      catch (Exception ee2) {
        return "// ERROR LOADING TYPES: " + ee2;
      }

   }

    string InterfaceOfType(Type T)
    {   
        Type t = T;     
        var sb = new StringBuilder();
        sb.AppendFormat("interface {0} {{\r\n", t.Name);
        foreach (var mi in GetInterfaceMembers(t))
        {
            sb.AppendFormat("  {0}: {1};\r\n", this.ToCamelCase(mi.Name), GetTypeName(mi));
        }
        sb.AppendLine("}");
        knownTypes.Add(t);
        return sb.ToString();
    }

    string Interface<T>()
    {   
        Type t = typeof(T);     
        var sb = new StringBuilder();
        sb.AppendFormat("interface {0} {{\n", t.Name);
        foreach (var mi in GetInterfaceMembers(t))
        {
            sb.AppendFormat("  {0}: {1};\r\n", this.ToCamelCase(mi.Name), GetTypeName(mi));
        }
        sb.AppendLine("}");
        knownTypes.Add(t);
        return sb.ToString();
    }

    IEnumerable<MemberInfo> GetInterfaceMembers(Type type)
    {
        return type.GetMembers(BindingFlags.Public | BindingFlags.Instance)
            .Where(mi => mi.MemberType == MemberTypes.Field || mi.MemberType == MemberTypes.Property);
    }

    string ToCamelCase(string s)
    {
        if (string.IsNullOrEmpty(s)) return s;
        if (s.Length < 2) return s.ToLowerInvariant();
        return char.ToLowerInvariant(s[0]) + s.Substring(1);
    }

    string GetTypeName(MemberInfo mi)
    {
        Type t = (mi is PropertyInfo) ? ((PropertyInfo)mi).PropertyType : ((FieldInfo)mi).FieldType;
        return this.GetTypeName(t);
    }

    string GetTypeName(Type t)
    {
        if(t.IsPrimitive)
        {
            if (t == typeof(bool)) return "boolean";
            if (t == typeof(char)) return "string";
            return "number";
        }
        if (t == typeof(decimal)) return "number";            
        if (t == typeof(string)) return "string";
        if (t.IsArray)
        {            
            var at = t.GetElementType();
            return this.GetTypeName(at) + "[]";
        }
        if(typeof (System.Collections.IEnumerable).IsAssignableFrom(t)) 
        {
            var collectionType = t.GetGenericArguments()[0]; // all my enumerables are typed, so there is a generic argument
            return GetTypeName(collectionType) + "[]";
        }            
        if (Nullable.GetUnderlyingType(t) != null)
        {
            return this.GetTypeName(Nullable.GetUnderlyingType(t));
        }
        if(t.IsEnum) return "number";
        if(knownTypes.Contains(t)) return t.Name;
        return "any";
    }

    string Enums<T>() // Enums<>, since Enum<> is not allowed.
    {
        Type t = typeof(T);        
        var sb = new StringBuilder();        
        int[] values = (int[])Enum.GetValues(t);
        sb.AppendLine("var " + t.Name + " = {");
        foreach(var val in values) 
        {
            var name = Enum.GetName(typeof(T), val);
            sb.AppendFormat("{0}: {1},\r\n", name, val);
        }
        sb.AppendLine("}");
        return sb.ToString();
    }
#>

วิธีแก้ปัญหาของฉันคือการเขียนเครื่องมือ codegen ขนาดเล็กที่ใช้เพียงแค่การประกอบโครงการ (และการอ้างอิงแอสเซมบลี) และเริ่มการสแกนประเภทที่เกี่ยวข้องกับการโต้ตอบระหว่าง typescript และ c # โปรแกรมอรรถประโยชน์นี้ส่งออกทั้งจาวาสคริปต์เป็น d.ts ... เครื่องมือนี้เรียกว่าในเหตุการณ์หลังการสร้าง ... ทำงานได้อย่างมีเสน่ห์!

หากสนใจคุณสามารถใช้TypedRpc จุดประสงค์ไม่เพียง แต่สร้างอินเทอร์เฟซใน TypeScript แต่เพื่อสร้างการสื่อสารทั้งหมดกับเซอร์วิสใน. Net โดยใช้โปรโตคอล JsonRpc

ตัวอย่างสำหรับคลาสในเซิร์ฟเวอร์:

[TypedRpc.TypedRpcHandler]
public class RpcServerExample
{
    public String HelloWorld()
    {
        return "Hello World!";
    }
}

การใช้รหัส TypeScript ที่สร้างขึ้น:

/// <reference path="Scripts/TypedRpc.ts" />

let rpc: TypedRpc.RpcServerExample = new TypedRpc.RpcServerExample();

var callback = function(data, jsonResponse) {
    console.log(data);
};

rpc.HelloWorld().done(callback).fail(callback);

ตรวจสอบhttps://github.com/Rodris/TypedRpcสำหรับตัวอย่างวิธีการใช้งานอื่น ๆ

ASP.NET Web API Client Generatorsอาจมีประโยชน์มากกว่ามีค่าใช้จ่ายน้อยกว่า toolchain แบบผยองและอื่น ๆ ระหว่าง SDLC

ในขณะที่โปรแกรมเมอร์โดยทั่วไปใช้ WebApiClientGen เพื่อสร้างรหัสไคลเอ็นต์ API แต่โครงการนี้ยังมี POCO2TS.exe ซึ่งเป็นโปรแกรมบรรทัดคำสั่งที่สร้างอินเตอร์เฟส TypsScript จากคลาส POCO คุณสามารถใช้ Poco2ts.exe หรือคอมโพเนนต์ poco2ts เพื่อรวมการสร้างโค้ดเข้ากับบิลด์ไลน์ของคุณ

หากคุณต้องการแปลงผ่าน node.js คุณสามารถใช้แพ็คเกจนี้ (csharp-to-typescript) https://www.npmjs.com/package/csharp-to-typescript

sourcode: https://github.com/YuvrajSagarRana/csharp-to-typescript

eg: 
// After installation, import the package.
var { CsharpToTs, getConfiguration } = require("csharp-to-typescript");

// Use CsharpToTs to convert your source code a. Method one give your source code as string:
const sourceCodeInString =   `public class Address
{
  public int Id {get; set;}
  public string Street { get; set; }
  public string City { get; set; }
}`

var outputTypescript = CsharpToTs(sourceCodeInString, getConfiguration());
console.log(outputTypescript);

// Output is

export class Address
{
  Id: number;
  Street: string;
  City: string;
}

หากคุณใช้ VSCode คุณสามารถดูส่วนขยายC # เป็น TypeScript ได้

ดูว่าฉันสามารถแปลงจากรหัส C # ได้อย่างไรในคลิกเดียว แน่นอนว่าไม่ใช่ทุกคลาสที่จะถูกแปลงเช่นโรงงาน แต่ก็ดีพอสำหรับฝั่งไคลเอ็นต์ เราต้องการเพียงรูปร่างของข้อมูล บางครั้งถ้าฉันจำเป็นต้องใช้รูปแบบผู้เยี่ยมชมฉันจะตกแต่งด้วยวิธีการเพิ่มเติมที่ฉันต้องการ ใช้เวลาเพียง 5 วินาทีในการทำเช่นนั้น เมื่อเปรียบเทียบกับหนึ่งนาทีข้างต้นฉันสามารถพูดได้ว่ามันเป็นชัยชนะที่ยิ่งใหญ่

ดูรายละเอียดเพิ่มเติมในบล็อกโพสต์ของฉัน