TypeScript 프로젝트에서 기존 C# 클래스 정의를 재사용하는 방법

TypeScript 프로젝트에서 기존 C# 클래스 정의를 재사용하는 방법

하겠습니다.TypeScript엔티티 프레임워크 도메인 모델이 이미 존재하는 MVC 프로젝트에 속하는 HTML 클라이언트 프로젝트에서 사용합니다.2개의 프로젝트(클라이언트측과 서버측)를 완전히 분리해 주세요.이렇게 때 사용합니다.JSON REST를 사용.

나의 론론, 제 of는domain클라이언트측 오브젝트는 서버측 오브젝트와 일치해야 합니다.과거에는 보통 수동으로 이 작업을 수행했습니다. C# 정의)를 할 수 있는 ?POJOTypeScript 。

현재 C#을 TypeScript에 매핑할 수 있는 것은 없습니다.POCO가 많거나 자주 변경될 수 있다고 생각되는 경우 변환기를 만들 수 있습니다. 즉, 다음과 같은 간단한 방법이 있습니다.

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

로.

export class MyPoco {
    public Name: string;
}

Codeplex에 대해서도 C#에서 자동 생성에 대해 설명합니다.

최신 상태를 유지하기 위해 TypeLite는 C#에서 TypeScript 인터페이스를 생성할 수 있습니다.

http://type.litesolutions.net/

Web Essentials를 통해 C# 파일을 TypeScript로 컴파일할 수 있습니다..d.ts파일을 저장합니다. 다음 '아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아,.tsfiles.complete files files files files files files files files.

vscode를 사용하는 경우 확장 csharp2ts를 사용할 수 있습니다.

C#하고, 「C#」을합니다.Convert C# to TypeScript명령어 팔레트A 변환 예:

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

TypeLite 및 T4위의 TS는 둘 다 양호해 보였고, Type Lite 중 하나를 선택했을 뿐이며, Type Lite의 지원을 받기 위해 포크를 설치했습니다.

• 값 유형,
• 무효
• camel Casing (TypeScript root doc은 낙타를 사용합니다.이것은 C#과 너무 잘 어울립니다)
• 퍼블릭 필드(깨끗하고 읽기 쉬운 POCO를 좋아합니다.또, C# 컴파일러도 간단하게 할 수 있습니다.
• 모듈 생성 비활성화

그리고 C# 인터페이스가 필요했고 이제 나만의 것을 만들 때가 되었다고 생각하고 내가 필요한 것을 하는 간단한 T4 스크립트를 작성했다.Enums도 포함됩니다.리포는 불필요합니다.T4는 100줄 미만입니다.

라이브러리도 NuGet도 없이 이 단순한 T4 파일만 사용할 수 있습니다. Visual Studio "T4 visual visual visual visual visual visual visual visual visual visual visual visual visual"그런 다음 이 파일을 붙여넣습니다.「ACME」를 선택합니다.마다 C#을 합니다.

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

순서에는 문제가 있지만, 다음의 인터페이스에서는 기존의 타입이 모두 사용됩니다.인터페이스만 사용하는 경우 파일 확장자는 .d.ts일 수 있습니다.enum의 경우 변수가 인스턴스화되기 때문에 .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 Json Controller 클래스에서 서비스 인터페이스를 작성하는 것입니다.

강화해 보세요.타이핑 프레임워크그게 네 문제를 해결해 주는 것 같아

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. 에 대해 한 작업을 수행하고 "POCO"를 참조하십시오.project.tsTypeScript 코코

자세한 내용은 문서 Wiki를 참조하십시오.

이 문제를 해결하기 위한 나의 접근 방식은 다음과 같습니다.속성을 사용하여 C# 클래스를 선언하면 (T4 변환을 사용하여) .d.ts 파일이 생성됩니다.Nuget에 패키지가 있고 소스를 github에서 사용할 수 있습니다.아직 프로젝트를 진행 중인데, 지원이 꽤 광범위해요.

Visual Studio를 사용하는 경우 타이프라이터 확장자를 추가합니다.

Visual Studio 갤러리

웹사이트/문서

갱신하다

VS 2015에 Web Essentials가 설치되어 있는 경우 클래스 파일을 오른쪽 클릭하여 컨텍스트메뉴에서> [ Web Essentials ]> [ Create Typescript Intellisense File ]를 선택합니다.

C# 클래스에서 TypeScript 인터페이스를 생성할 수 있는 작은 유틸리티를 만들었습니다.NuGet 패키지로 제공됩니다.자세한 문서는 프로젝트 웹 페이지에서 확인할 수 있습니다.

이 도서관 타이프라이터를 보세요.

클래스, enum, 인터페이스 등뿐 아니라 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[];
}

생성된 모든 TypeScript 클래스/인터페이스에 대해 개별 파일을 만들어야 할 경우(즉, "파일당 단일 클래스" 방식으로) TypeGen을 사용해 볼 수 있습니다.패키지 매니저 콘솔에서 C# 클래스/enum에 따라 TypeScript 파일을 생성할 수 있는 도구입니다.현재 지원되는 것은 다음과 같습니다.

• 내보내기, Enum; TS 클래스 또는 인터페이스로 POCO 내보내기
• 상속.
• 범용형
• 컬렉션/네스트된 컬렉션 유형

기타 몇 가지 추가 기능이 있습니다.오픈 소스이기도 합니다(github에서 확인할 수 있습니다).

오픈 소스 프로젝트 NSwag를 사용할 수 있습니다.GUI 에서는, 을 선택할 수 있습니다.기존 NET 클래스NET DLL 및 NET DLL에 대한 TypeScript 인터페이스를 생성합니다.

이 프로젝트에서는 명령줄 툴과 T4 템플릿 지원 및 Web API 컨트롤러용 클라이언트 코드 생성도 제공합니다.

남성분들은 https://github.com/reinforced/Reinforced.Typings을 보시기 바랍니다.저는 지난 며칠간 Typelite와 t4 템플릿을 가지고 놀다가 이 프로젝트를 하게 되었습니다.그것은 매우 심플하고 매력적으로 작용한다.패키지를 가져와 컨피규레이션파일(10초 정도)을 수정하고 빌드하기만 하면 됩니다.모든 작업이 문제 없이 자동으로 수행됩니다.저자를 축복하라!

T4 템플릿의 단점은 VS에서 빌드하면 스캔된 어셈블리가 잠기고 VS를 재시작해야 한다는 것입니다(얼마나 어리석은 일입니까).T4 Toolbox + VS Cleaning Directive에는 몇 가지 회피책이 있지만, 어느 것도 효과가 없었습니다.

https://github.com/pankleks/TypeScriptBuilder 를 사용할 수도 있습니다.

이 작은 라이브러리는 C# 유형을 기반으로 TypeScript 유형 정의를 생성합니다.백엔드 C# 프로젝트에서 직접 사용하여 프런트엔드 TypeScript 프로젝트의 코드를 생성합니다.또한 작은 콘솔 앱을 작성하여 사전 빌드 도구로 코드를 생성할 수도 있습니다.

풀 및 NET Core 프레임워크로 동작합니다.

에 의한 : nuget 설설:Install-Package TypeScriptBuilder

지원되는 기능

• 유형 종속성 해결
• 범용
• 상속 유형
• 네임스페이스(모듈)
• 에넘
• 특수한 유형
• 사전 변환(강력한 유형의 TS 인덱스 개체로)
• 코드 생성 제어 속성 세트
• any할 수 없는

상세내용 : https://github.com/pankleks/TypeScriptBuilder/blob/master/README.md

Developer Community 페이지에 다음과 같은 기능 요청을 작성했습니다.

https://developercommunity.visualstudio.com/idea/1153873/reuse-existing-net-classes-for-typescript-definiti.html

이 답변에서 알 수 있듯이 많은 프로젝트가 이 문제를 해결하려고 시도하고 있지만 안타깝게도 이러한 프로젝트의 대부분은 단일 개발자 프로젝트로 진행 중 지원이 중단됩니다.마이크로소프트가 대신 이 프로젝트들 중 하나를 유지한다면 정말 좋을 것 같습니다..NET로로 합니다.TypeScript발전기

그 중에서도 일부는 여전히 유지 보수되고 있지만, 한 명의 개발자에 크게 의존하고 있습니다.

TypeLite:

https://bitbucket.org/LukasKabrt/typelite/src/default/

TypeScript 정의 생성기:

https://marketplace.visualstudio.com/items?itemName=MadsKristensen.TypeScriptDefinitionGenerator

타이프라이터:

https://github.com/frhagn/Typewriter

Type Gen:

https://github.com/jburzynski/TypeGen

강화되었습니다.타이핑:

https://github.com/reinforced/Reinforced.Typings

제 조언은 처음부터 당신이 유지보수를 중단하고 현재 유지보수를 하고 있는 것으로 바꿀 준비가 되어 있는 프로젝트를 선택하는 것입니다.만약 그 프로젝트가 더 이상 지원되지 않는다면, 저는 그 태그를 다른 것으로 바꿀 수 있을 것입니다.

그 반대는 어떻습니까?

erecruit TypeScript Translator 를 확인해 주세요.즉시 사용할 수 있는 C# 지원이 제공되지만 실제로는 템플릿 기반(렌더링에 Nunjucks 사용)이므로 다른 모든 것(VB)을 생성할 수 있습니다.NET, F#, C++, XML, SQL - 템플릿으로 인코딩할 수 있는 모든 것.

로서 기능합니다.NET 콘솔 프로그램, NodeJS 프로그램(Windows가 아닌 경우) 또는 Visual Studio 확장 기능으로 저장 시 생성 기능을 제공합니다.또한 빌드 서버를 만족시키기 위해 MSBuild 지원도 포함되어 있습니다. :-)

난 도시애 솔루션이 좋아.조금 더 늘렸어요.따라서 솔루션은 T4 템플릿을 사용한 코드 생성 기술도 기반으로 합니다.

일반적인 TypeScript 유형 및 환경 선언을 생성할 수 있습니다.

상속 및 인터페이스 구현을 지원합니다.

범용, 배열 및 목록을 유형 필드로 지원합니다.

또한 설정에서 명시적으로 언급되지 않은 TypeScript 유형으로 변환됩니다(예를 들어 유형 A를 Import하고 TS 출력에서 필드의 유형, 기본 유형 및 인터페이스 등 다른 유형을 찾을 수 있습니다.

유형 이름을 재정의할 수도 있습니다.

Enum도 지원됩니다.

사용 예(프로젝트 저장소에서 찾을 수 있음):

// 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부터는 C# 타입의 TypeScript 정의 생성을 지원합니다.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();
    }
#>

이 솔루션은 프로젝트 어셈블리(및 레퍼링 어셈블리)를 사용하여 typescript와 c#의 상호작용에 관여하는 유형의 스캔을 시작하는 작은 codegen util을 작성하는 것이었습니다.이 유틸리티는 둘 다 javascript를 d.ts...로 출력합니다.빌드 후의 이벤트에서는 툴이라고 불리고 있습니다...마법처럼 기능합니다!

관심 있는 경우 Type Rpc를 사용할 수 있습니다.그 목적은 TypeScript에서 인터페이스를 작성하는 것뿐만 아니라의 서비스와의 모든 통신을 작성하는 것입니다.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는 SDLC 중에 swag 툴 체인이나 다른 툴 체인보다 편리하고 오버헤드가 적을 수 있습니다.

프로그래머는 일반적으로 WebApiClientGen을 사용하여 클라이언트 API 코드를 생성하지만 이 프로젝트에서는 POCO 클래스에서 TypeScript 인터페이스를 생성하는 명령줄 프로그램인 POCO2TS.exe도 제공합니다.Poco2t 중 하나를 사용하셔도 됩니다.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를 사용하는 경우 TypeScript 확장 C#을 살펴볼 수 있습니다.

클릭 한 번으로 C# 코드에서 변환하는 방법을 확인하십시오.물론 공장 등 모든 클래스가 전환되는 것은 아니지만, 클라이언트 측에서는 충분합니다.데이터의 형태만 있으면 됩니다.가끔 방문자 패턴을 사용해야 할 경우, 필요한 추가 방법으로 꾸밀 수 있습니다.그렇게 하는 데 5초밖에 걸리지 않았어요.1분 전과 비교하면 대승이라고 할 수 있다.

자세한 내용은 블로그 투고를 참조하십시오.

TypeScript와 C# DTO/POCO 클래스를 모두 생성하는 작은 커스텀 DSL을 사용합니다.DSL의 외관은 다음과 같습니다.

output CSharp
output TypeScript

namespace MyLibrary.Logic.DataModel.DTOs

class Something

property int ID
property string Name
property DateTime DateTime
property int ForeignKeyID

이렇게 하면 단일 소스(DSL)를 가지며 2개의 C# 및 TypeScript 로직 모델 사이에 있는 DTO 모델을 갖게 됩니다.

다음으로 DTO 객체와 Logic Model 객체 간의 변환을 담당하는 메서드가 있는 C# 및 TypeScript DTOFactory 클래스를 작성합니다(DTO 생성의 일부는 직렬화 또는 IndexedDB에 저장하기 위해 익명 JSON으로 변환하는 직렬화 메서드입니다).

이렇게 하면 어느 쪽이든 기종이 바뀌면 다시 일치할 때까지 컴파일 오류가 발생합니다.

언급URL : https://stackoverflow.com/questions/12957820/how-to-reuse-existing-c-sharp-class-definitions-in-typescript-projects