Cách sử dụng lại các định nghĩa lớp C # hiện có trong các dự án TypeScript

Tôi sẽ bắt đầu sử dụng TypeScripttrong dự án khách hàng HTML của mình, dự án này thuộc dự án MVC với mô hình miền khung thực thể đã có ở đó. Tôi muốn hai dự án của mình (phía máy khách và phía máy chủ) hoàn toàn tách biệt vì hai nhóm sẽ làm việc trên này ... JSON và REST được sử dụng để giao tiếp các đối tượng qua lại.

Tất nhiên, domaincác đối tượng của tôi ở phía máy khách phải khớp với các đối tượng ở phía máy chủ. Trong quá khứ, tôi thường làm điều này theo cách thủ công. Có cách nào để sử dụng lại các định nghĩa lớp C # của tôi (đặc biệt là các POJOlớp trong mô hình miền của tôi) để tạo các lớp tương ứng trong TypeScript "không?

Hiện tại không có bất kỳ thứ gì sẽ ánh xạ C # sang TypeScript. Nếu bạn có nhiều POCO hoặc bạn nghĩ chúng có thể thay đổi thường xuyên, bạn có thể tạo một công cụ chuyển đổi - một cái gì đó đơn giản dọc theo ...

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

Đến

export class MyPoco {
    public Name: string;
}

Ngoài ra còn có một cuộc thảo luận trên Codeplex về việc tự động tạo từ C # .

Chỉ để cập nhật mọi thứ, TypeLite có thể tạo giao diện TypeScript từ C #:

http://type.litesolutions.net/

Web Essentials cho phép biên dịch tệp C # thành tệp TypeScript .d.tskhi lưu. Sau đó, bạn có thể tham khảo các định nghĩa từ các .tstệp của mình .

TypeLite và T4TS ở trên đều có vẻ tốt, chỉ cần chọn một cái, TypeLite, chia nhỏ nó để được hỗ trợ

• ValueTypes ,
• Nullables
• camelCasing (tài liệu gốc của TypeScript sử dụng lạc đà và điều này rất tốt khi kết hợp với C #)
• các trường công cộng (yêu thích các POCO sạch và dễ đọc, cũng giúp cho Trình biên dịch C # trở nên dễ dàng)
• vô hiệu hóa tạo mô-đun

Sau đó, tôi cần các giao diện C # và nghĩ rằng đã đến lúc nướng thứ của riêng mình và viết một tập lệnh T4 đơn giản chỉ làm những gì tôi cần. Nó cũng bao gồm Enums . Không cần repo, chỉ cần <100 dòng T4.

Cách sử dụng
Không có thư viện, không có NuGet, chỉ cần tệp T4 đơn giản này - sử dụng "thêm mục" trong Visual Studio và chọn bất kỳ mẫu T4 nào. Sau đó, dán nó vào tệp. Điều chỉnh mọi dòng với "ACME" trong đó. Đối với mỗi lớp C #, hãy thêm một dòng

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

Vấn đề đặt hàng, bất kỳ loại nào đã biết sẽ được sử dụng trong các giao diện follwing. Nếu bạn chỉ sử dụng giao diện, phần mở rộng tệp có thể là .d.ts , đối với enums, bạn cần tệp .ts , vì một biến được khởi tạo.

Tùy chỉnh
Hack kịch bản.

<#@ 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();
    }
#>

Cấp độ tiếp theo của script sẽ là tạo giao diện dịch vụ từ lớp MVC JsonController.

Nếu bạn sử dụng vscode, bạn có thể sử dụng csharp2ts tiện ích mở rộng của tôi , nó thực hiện chính xác điều đó.

Bạn chỉ cần chọn mã C # đã dán và chạy Convert C# to TypeScriptlệnh từ bảng lệnh Một ví dụ chuyển đổi:

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

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

đến

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

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

Đây là cách tiếp cận của tôi để giải quyết nó. Khai báo các lớp C # của bạn với một thuộc tính và tệp .d.ts sẽ được tạo (sử dụng biến đổi T4). Có một gói trên nuget và nguồn có sẵn trên github . Tôi vẫn đang làm việc trong dự án, nhưng sự hỗ trợ khá rộng rãi.

Nếu bạn đang sử dụng Visual Studio, hãy thêm phần mở rộng Máy đánh chữ.

Thư viện Visual Studio

Trang web / Tài liệu

Cập nhật

Với Web Essentials được cài đặt trong VS 2015, bạn có thể nhấp chuột phải vào tệp lớp, sau đó bấm> Web Essentials> Tạo tệp tin Intellisense Typescript từ menu ngữ cảnh.

Hãy thử khung Reinforced.Typings. Có vẻ như nó giải quyết được vấn đề của bạn.

1. Cài đặt nó từ NuGet

2. Điều hướng đến POCO của bạn và thêm [TsInterface]thuộc tính bên trên nó

   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. Xây dựng lại dự án của bạn

4. Tìm mã TypeScript được tạo trong %Your_Project_Directory%/Scripts/project.tstệp và thêm nó vào dự án theo cách thủ công

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

5. Làm tương tự cho tất cả POCO của bạn và tham chiếu project.tstrong mã TypeScript khác của bạn.

Xem thêm chi tiết trong wiki tài liệu

Tôi đã tạo một tiện ích nhỏ có thể tạo giao diện TypeScript từ các lớp C #. Có sẵn dưới dạng gói NuGet . Tài liệu chi tiết có thể được tìm thấy trên trang web của dự án .

Vui lòng xem thư viện Máy đánh chữ này

Nó chuyển đổi không chỉ các lớp, enum, giao diện, v.v. mà còn cả các bộ điều khiển api, điều này thật tuyệt vời ..

Thêm vào đó, nó thực hiện điều này ngay khi bạn lưu tệp .cs nguồn, vì vậy tôi không phải kích hoạt bất kỳ công cụ bên ngoài nào. Lưu .cs và bạn sẽ được cập nhật .ts

Tôi có một giải pháp nhỏ sử dụng các mẫu T4 ( xem nguồn ).

Bạn đi từ bất kỳ CLR POCO nào:

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

Đối với giao diện TypeScript:

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

Bạn có thể sử dụng dự án mã nguồn mở NSwag : Trong GUI, bạn có thể chọn lớp .NET từ một DLL .NET hiện có và tạo giao diện TypeScript cho nó.

Dự án cũng cung cấp các công cụ dòng lệnh và hỗ trợ cho các mẫu T4 cũng như tạo mã máy khách cho bộ điều khiển API Web ...

Nếu bạn cần tạo một tệp riêng biệt cho mọi lớp / giao diện TypeScript được tạo (tức là theo cách "một lớp cho mỗi tệp"), bạn có thể thử TypeGen . Đó là một công cụ bạn có thể sử dụng từ Bảng điều khiển Trình quản lý Gói để tạo các tệp TypeScript dựa trên các lớp / enums C # của bạn. Nó hiện hỗ trợ:

• xuất khẩu enums; xuất POCO dưới dạng các lớp hoặc giao diện TS
• di sản
• loại chung chung
• bộ sưu tập / loại bộ sưu tập lồng nhau

cộng với một số tính năng bổ sung. Nó cũng là mã nguồn mở (bạn có thể kiểm tra trên github ).

Làm thế nào về cách khác xung quanh?

Kiểm tra Trình dịch TypeScript của ECruit . Nó đi kèm với hỗ trợ C # sẵn sàng hoạt động, nhưng thực sự dựa trên mẫu (sử dụng Nunjucks để kết xuất), có nghĩa là nó có thể tạo ra bất kỳ thứ gì khác - VB.NET, F #, C ++, XML, SQL - bất cứ thứ gì bạn có thể mã hóa bằng mẫu.

Hoạt động như một chương trình bảng điều khiển .NET, chương trình NodeJS (dành cho những người không có trên Windows) hoặc như một phần mở rộng Visual Studio , hoàn chỉnh với chức năng tạo khi lưu. Và bao gồm hỗ trợ MSBuild, chỉ để làm cho máy chủ xây dựng của bạn hài lòng. :-)

Bạn cũng có thể sử dụng cái này: https://github.com/pankleks/TypeScriptBuilder

Thư viện nhỏ này tạo ra định nghĩa kiểu TypeScript dựa trên các kiểu C #. Sử dụng nó trực tiếp trong dự án C # phụ trợ của bạn để tạo mã cho dự án TypeScript giao diện người dùng của bạn. Bạn cũng có thể sử dụng ứng dụng console nhỏ để tạo mã bằng các công cụ tạo sẵn.

Hoạt động trên khung Full & NET Core!

Cài đặt bởi nuget: Install-Package TypeScriptBuilder

Các tính năng được hỗ trợ

• Giải quyết loại phụ thuộc
• Generics
• Nhập kế thừa
• Không gian tên (mô-đun)
• Enums
• Loại vô hiệu
• Đối chiếu từ điển (đối với các đối tượng được lập chỉ mục TS loại mạnh)
• Tập hợp các thuộc tính điều khiển tạo mã
• any cho các loại không thể chuyển đổi

Mô tả thêm: https://github.com/pankleks/TypeScriptBuilder/blob/master/README.md

Các bạn xem qua https://github.com/reinforced/ Reinforced.Typings . Tôi đã chơi với các mẫu typelite và t4 trong vài ngày qua và kết thúc với dự án này. Nó siêu đơn giản và hoạt động như một sự quyến rũ. Chỉ cần lấy gói, sửa đổi tệp cấu hình (giống như trong 10 giây) và xây dựng. Tất cả được thực hiện tự động mà không có bất kỳ vấn đề nào. Chúc phúc cho tác giả!

Điều tồi tệ về các mẫu T4 là một khi bạn xây dựng từ VS, các hội đồng được quét sẽ bị khóa và bạn phải khởi động lại VS (thật ngớ ngẩn làm sao?). Có một số cách giải quyết trong Hộp công cụ T4 + một số chỉ thị làm sạch VS nhưng không có cách nào trong số này phù hợp với tôi.

Tôi thích giải pháp citykid. Tôi đã mở rộng nó một chút. Vì vậy, giải pháp cũng dựa trên kỹ thuật tạo mã với mẫu T4.

Nó có thể tạo ra các loại TypeScript phổ biến và khai báo môi trường xung quanh.

Nó hỗ trợ kế thừa và triển khai giao diện.

Hỗ trợ chung, mảng và danh sách dưới dạng trường kiểu.

Ngoài ra, nó dịch sang các loại TypeScript không được đề cập rõ ràng trong cấu hình (ví dụ: chúng tôi nhập loại A và trong đầu ra TS, bạn có thể tìm thấy một số loại khác: loại trường, loại cơ sở và giao diện).

Bạn cũng có thể ghi đè tên của loại.

Enums cũng được hỗ trợ.

Ví dụ về cách sử dụng (bạn có thể tìm thấy nó trong kho dự án):

// 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" #>

Và bạn sẽ nhận được một đầu ra

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

Kiểm tra toàn bộ giải pháp tại đây: https://bitbucket.org/chandrush/cst4ts

Bạn cũng có thể sử dụng Bridge.net. Từ phiên bản 1.7, nó hỗ trợ tạo các định nghĩa TypeScript cho các loại C #. Xem http://bridge.net/docs/generate-typescript-definitions/

Tôi cũng rất thích câu trả lời của @ citykid, vì vậy tôi đã mở rộng nó để thực hiện toàn bộ không gian tên cùng một lúc. Chỉ cần đặt các lớp POCO vào không gian tên và xây dựng lại các mẫu T4. Tôi ước mình biết cách tạo các tệp riêng biệt cho từng tệp, nhưng đó không phải là ngày tận thế.

Bạn cần tham chiếu các tệp .DLL ở phần trên cùng (nơi chứa các lớp mà bạn muốn) và bạn cần đề cập đến các không gian tên. Tất cả các dòng để chỉnh sửa được đánh dấu bằng ACME. Những điều đáng mừng cho @citykid, hãy đánh giá cao nó!

<#@ 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();
    }
#>

Giải pháp của tôi là viết một đoạn mã nhỏ sử dụng chỉ đơn giản là lấy một tổ hợp dự án (và các hội đồng tham chiếu) và bắt đầu quét các kiểu có liên quan đến sự tương tác giữa các typecript và c #. Sử dụng này xuất ra cả javascript dưới dạng d.ts ... Công cụ được gọi trong sự kiện sau xây dựng ... hoạt động như một sự quyến rũ!

Nếu quan tâm, bạn có thể sử dụng TypedRpc . Mục đích của nó không chỉ là tạo các giao diện trong TypeScript mà còn tạo ra tất cả các giao tiếp với dịch vụ trong .Net bằng giao thức JsonRpc.

Ví dụ cho một lớp trong máy chủ:

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

Cách sử dụng mã TypeScript đã tạo:

/// <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);

Hãy xem https://github.com/Rodris/TypedRpc để biết các ví dụ khác về cách sử dụng nó.

ASP.NET Web API Client Generator có thể tiện dụng hơn, ít chi phí hơn so với chuỗi công cụ swagger và những thứ khác trong SDLC.

Trong khi các lập trình viên thường sử dụng WebApiClientGen để tạo mã API máy khách, dự án này cũng cung cấp POCO2TS.exe, một chương trình dòng lệnh tạo giao diện TypsScript từ các lớp POCO. Bạn có thể sử dụng Poco2ts.exe hoặc thành phần poco2ts để tích hợp việc tạo mã với đường dẫn xây dựng của bạn.

Nếu bạn muốn chuyển đổi nó thông qua node.js thì bạn có thể sử dụng gói này (csharp-to-stylescript). https://www.npmjs.com/package/csharp-to-typescript

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

Nếu bạn đang sử dụng VSCode, bạn có thể xem phần mở rộng C # thành TypeScript

Xem cách tôi có thể chuyển đổi nó từ mã C # chỉ bằng một cú nhấp chuột. Tất nhiên, không phải tất cả các lớp sẽ được chuyển đổi chẳng hạn như factory, nhưng nó đủ tốt cho phía máy khách. Chúng ta chỉ cần hình dạng của dữ liệu. Đôi khi Nếu tôi cần sử dụng mẫu khách, tôi sẽ trang trí bằng các phương pháp bổ sung mà tôi cần. Chỉ mất 5 giây để làm như vậy. So sánh với một phút ở trên, tôi có thể nói đó là một chiến thắng lớn.

Xem thêm chi tiết trong bài đăng trên blog của tôi