So verwenden Sie vorhandene C # -Klassendefinitionen in TypeScript-Projekten wieder

Ich werde gerade mit der Verwendung TypeScriptin meinem HTML-Client-Projekt beginnen, das zu einem MVC-Projekt gehört, in dem bereits ein Entity-Framework-Domänenmodell vorhanden ist. Ich möchte, dass meine beiden Projekte (Client- und Serverseite) vollständig getrennt sind, da zwei Teams daran arbeiten werden ... JSON und REST werden verwendet, um Objekte hin und her zu kommunizieren.

Natürlich sollten meine domainObjekte auf der Clientseite mit den Objekten auf der Serverseite übereinstimmen. In der Vergangenheit habe ich dies normalerweise manuell gemacht. Gibt es eine Möglichkeit, meine C # POJO-Klassendefinitionen (insbesondere der Klassen in meinem Domänenmodell) wiederzuverwenden , um die entsprechenden Klassen in TypeScript zu erstellen?

Derzeit gibt es nichts, was C # TypeScript zuordnen könnte. Wenn Sie viele POCOs haben oder glauben, dass sie sich häufig ändern, können Sie einen Konverter erstellen - etwas Einfaches im Sinne von ...

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

Zu

export class MyPoco {
    public Name: string;
}

Es gibt auch eine Diskussion über Codeplex über die automatische Generierung aus C # .

Um die Dinge auf dem neuesten Stand zu halten, kann TypeLite TypeScript-Schnittstellen aus C # generieren:

http://type.litesolutions.net/

Mit Web Essentials können C # -Dateien beim Speichern in TypeScript- .d.tsDateien kompiliert werden . Dann könnten Sie auf die Definitionen aus Ihren .tsDateien verweisen .

TypeLite und T4TSs oben sahen beide gut aus. Sie haben nur einen ausgewählt, TypeLite, und ihn gegabelt, um Unterstützung zu erhalten

• ValueTypes ,
• Nullables
• camelCasing (TypeScript- Stammdokument verwendet Kamele, und dies passt zu gut zu C #)
• öffentliche Felder (lieben saubere und lesbare POCOs, machen es auch dem C # -Compiler leicht)
• Modulgenerierung deaktivieren

Dann brauchte ich C # -Schnittstellen und dachte, es sei Zeit, mein eigenes Ding zu backen, und schrieb ein einfaches T4-Skript, das genau das tut, was ich brauche. Es enthält auch Aufzählungen . Kein Repo erforderlich, nur <100 Zeilen T4.

Verwendung
Keine Bibliothek, kein NuGet, nur diese einfache T4-Datei - verwenden Sie "Element hinzufügen" in Visual Studio und wählen Sie eine beliebige T4-Vorlage aus. Fügen Sie dies dann in die Datei ein. Passen Sie jede Zeile mit "ACME" an. Fügen Sie für jede C # -Klasse eine Zeile hinzu

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

In Bezug auf die Reihenfolge wird jeder bekannte Typ in den folgenden Schnittstellen verwendet. Wenn Sie nur Schnittstellen verwenden, kann die Dateierweiterung .d.ts sein . Für Aufzählungen benötigen Sie eine .ts- Datei, da eine Variable instanziiert wird.

Anpassung
Hacken Sie das Skript.

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

Die nächste Ebene des Skripts besteht darin, die Dienstschnittstelle aus der MVC JsonController-Klasse zu erstellen.

Wenn Sie vscode verwenden, können Sie meine Erweiterung csharp2ts verwenden die genau das tut.

Sie wählen einfach den eingefügten C # -Code aus und führen den Convert C# to TypeScriptBefehl über die Befehlspalette aus. Ein Konvertierungsbeispiel:

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

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

zu

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

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

Wenn Sie Visual Studio verwenden, fügen Sie die Typewriter-Erweiterung hinzu.

Visual Studio-Galerie

Website / Dokumentation

Aktualisieren

Wenn Web Essentials in VS 2015 installiert ist, können Sie mit der rechten Maustaste auf die Klassendatei klicken und dann im Kontextmenü auf> Web Essentials> Typescript Intellisense-Datei erstellen.

Hier ist mein Lösungsansatz. Deklarieren Sie Ihre C # -Klassen mit einem Attribut und .d.ts-Dateien werden generiert (mithilfe von T4-Transformationen). Es gibt ein Paket auf Nuget und die Quelle ist auf Github verfügbar . Ich arbeite noch an dem Projekt, aber der Support ist ziemlich umfangreich.

Versuchen Sie es mit dem Reinforced.Typings-Framework. Scheint, dass es Ihr Problem löst.

1. Installieren Sie es von NuGet

2. Navigieren Sie zu Ihrem POCO und fügen Sie darüber ein [TsInterface]Attribut hinzu

   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. Erstellen Sie Ihr Projekt neu

4. Finden Sie den generierten TypeScript-Code in der %Your_Project_Directory%/Scripts/project.tsDatei heraus und fügen Sie ihn manuell zum Projekt hinzu

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

5. Machen Sie dasselbe für alle Ihre POCOs und Verweise project.tsin Ihrem anderen TypeScript-Code.

Weitere Details finden Sie im Dokumentations-Wiki

Ich habe ein kleines Dienstprogramm erstellt, das TypeScript-Schnittstellen aus C # -Klassen generieren kann. Ist als NuGet-Paket erhältlich . Eine ausführliche Dokumentation finden Sie auf der Projektwebseite .

Bitte schauen Sie sich diese Bibliothek Schreibmaschine an

Es konvertiert nicht nur Klassen, Aufzählungen, Schnittstellen usw., sondern auch die API-Controller, was einfach fantastisch ist.

Außerdem funktioniert dies, sobald Sie die CS-Quelldatei speichern, sodass ich kein externes Tool auslösen muss. Speichern Sie .cs und Sie erhalten .ts aktualisiert

Ich habe eine kleine Lösung, die T4-Vorlagen verwendet ( Quelle anzeigen ).

Sie gehen von jedem CLR POCO:

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

Zu einer TypeScript-Schnittstelle:

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

Sie können das Open-Source-Projekt NSwag verwenden : In der GUI können Sie die .NET-Klasse aus einer vorhandenen .NET-DLL auswählen und die TypeScript-Schnittstelle dafür generieren.

Das Projekt bietet außerdem Befehlszeilentools und Unterstützung für T4-Vorlagen sowie die Generierung von Clientcode für Web-API-Controller ...

Wenn Sie für jede generierte TypeScript-Klasse / -Schnittstelle eine separate Datei erstellen müssen (dh in einer "einzelnen Klasse pro Datei"), können Sie TypeGen ausprobieren . Mit diesem Tool können Sie über die Package Manager-Konsole TypeScript-Dateien basierend auf Ihren C # -Klassen / Aufzählungen generieren. Es unterstützt derzeit:

• Exportieren von Aufzählungen; Exportieren von POCOs als TS-Klassen oder Schnittstellen
• Erbe
• generische Typen
• Sammlung / verschachtelte Sammlungstypen

plus einige zusätzliche Funktionen. Es ist auch Open Source (Sie können es auf Github überprüfen ).

Wie wäre es umgekehrt?

Schauen Sie sich erecruit TypeScript Translator an . Es wird mit sofort einsatzbereiter C # -Unterstützung geliefert, ist jedoch tatsächlich vorlagenbasiert (verwendet Nunjucks zum Rendern), was bedeutet, dass alles andere generiert werden kann - VB.NET, F #, C ++, XML, SQL - was auch immer Sie mit einer Vorlage codieren können.

Funktioniert als .NET-Konsolenprogramm, NodeJS-Programm (für Benutzer ohne Windows) oder als Visual Studio-Erweiterung mit Funktionen zum Generieren beim Speichern. Und beinhaltet MSBuild-Unterstützung, nur um Ihren Build-Server glücklich zu machen. :-)

Sie können dies auch verwenden: https://github.com/pankleks/TypeScriptBuilder

Diese kleine Bibliothek generiert eine TypeScript-Typdefinition basierend auf C # -Typen. Verwenden Sie es direkt in Ihrem Backend-C # -Projekt, um Code für Ihr Frontend-TypeScript-Projekt zu generieren. Sie können auch eine kleine Konsolen-App schreiben, um Code mit vorgefertigten Tools zu generieren.

Funktioniert mit dem Full & NET Core Framework!

Installation per Nuget: Install-Package TypeScriptBuilder

Unterstützte Funktionen

• Typabhängigkeit auflösen
• Generika
• Typvererbung
• Namespaces (Module)
• Aufzählungen
• Nullable Typen
• Wörterbuchkonvertierung (zu starken TS-indizierten Objekten)
• Satz von Steuerattributen für die Codegenerierung
• any für Typen, die nicht konvertiert werden können

Weitere Beschreibung: https://github.com/pankleks/TypeScriptBuilder/blob/master/README.md

Jungs schauen sich das an https://github.com/reinforced/ Reinforced.Typings an . Ich habe in den letzten Tagen mit Typelite- und T4-Vorlagen gespielt und bin zu diesem Projekt gekommen. Es ist super einfach und wirkt wie ein Zauber. Holen Sie sich einfach das Paket, ändern Sie die Konfigurationsdatei (wie für 10 Sekunden) und erstellen Sie. Alles wird automatisch ohne Probleme erledigt. Segne den Autor!

Das Schlechte an T4-Vorlagen ist, dass die gescannten Assemblys nach dem Erstellen aus VS gesperrt sind und Sie VS neu starten müssen (wie dumm ist das?). Es gibt einige Problemumgehungen in T4 Toolbox + einige VS-Reinigungsanweisungen, aber keine davon hat bei mir funktioniert.

Ich mag die Citykid-Lösung. Ich hatte es ein wenig verlängert. Die Lösung basiert also auch auf der Codegenerierungstechnik mit T4-Vorlagen.

Es kann allgemeine TypeScript-Typen und Umgebungsdeklarationen generieren.

Es unterstützt Vererbungs- und Schnittstellenimplementierungen.

Unterstützt Generika, Arrays und Listen als Typfelder.

Außerdem werden TypeScript-Typen übersetzt, die in der Konfiguration nicht explizit erwähnt werden (zum Beispiel importieren wir Typ A, und in der TS-Ausgabe finden Sie einige andere Typen: Feldtypen, Basistypen und Schnittstellen).

Sie können auch den Namen des Typs überschreiben.

Aufzählungen werden ebenfalls unterstützt.

Verwendungsbeispiel (Sie finden es im Projekt-Repository):

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

Und Sie erhalten eine Ausgabe

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

Die vollständige Lösung finden Sie hier: https://bitbucket.org/chandrush/cst4ts

Sie können auch Bridge.net verwenden. Ab Version 1.7 wird die Generierung von TypeScript-Definitionen für C # -Typen unterstützt. Siehe http://bridge.net/docs/generate-typescript-definitions/

Die Antwort von @ citykid hat mir auch sehr gut gefallen, deshalb habe ich sie erweitert, um jeweils einen ganzen Namespace zu erstellen. Fügen Sie einfach die POCO-Klassen in den Namespace ein und erstellen Sie die T4-Vorlagen neu. Ich wünschte, ich wüsste, wie man separate Dateien für jede generiert, aber das ist nicht das Ende der Welt.

Sie müssen auf die DLL-Dateien im oberen Teil verweisen (wo sich die gewünschten Klassen befinden) und die Namespaces angeben. Alle zu bearbeitenden Zeilen sind mit ACME markiert. Ein großes Lob an @citykid, danke!

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

Meine Lösung bestand darin, ein kleines Codegen-Util zu schreiben, das einfach eine Projektassembly (und referenzierende Assemblys) benötigt und mit dem Scannen von Typen beginnt, die an der Interaktion zwischen Typoskript und c # beteiligt sind. Dieses util gibt beide Javascript als d.ts aus ... Das Tool wird im Post-Build-Event aufgerufen ... funktioniert wie ein Zauber!

Bei Interesse können Sie TypedRpc verwenden . Der Zweck besteht nicht nur darin, die Schnittstellen in TypeScript zu erstellen, sondern die gesamte Kommunikation mit dem Dienst in .Net mithilfe des JsonRpc-Protokolls zu erstellen.

Beispiel für eine Klasse im Server:

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

Verwendung des generierten TypeScript-Codes:

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

Weitere Beispiele für die Verwendung finden Sie unter https://github.com/Rodris/TypedRpc .

ASP.NET Web API-Clientgeneratoren möglicherweise praktischer und haben weniger Aufwand als die Swagger-Toolchain und andere während der SDLC.

Während Programmierer im Allgemeinen WebApiClientGen verwenden, um Client-API-Codes zu generieren, bietet dieses Projekt auch POCO2TS.exe, ein Befehlszeilenprogramm, das TypsScript-Schnittstellen aus POCO-Klassen generiert. Sie können entweder Poco2ts.exe oder die poco2ts-Komponente verwenden, um die Codegenerierung in Ihre Build-Pipeline zu integrieren.

Wenn Sie es über node.js konvertieren möchten, können Sie dieses Paket (csharp-to-typescript) verwenden. https://www.npmjs.com/package/csharp-to-typescript

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

Wenn Sie VSCode verwenden, können Sie sich diese Erweiterung C # für TypeScript ansehen

Sehen Sie, wie ich es mit nur einem Klick aus C # -Code konvertieren kann. Natürlich werden nicht alle Klassen wie die Factory konvertiert, aber es ist gut genug für die Client-Seite. Wir brauchen nur die Form von Daten. Manchmal, wenn ich das Besuchermuster verwenden muss, werde ich mit zusätzlichen Methoden dekorieren, die ich benötige. Es dauerte nur etwa 5 Sekunden, um dies zu tun. Im Vergleich zu einer Minute oben könnte ich sagen, dass es ein großer Gewinn ist.

Weitere Details finden Sie in meinem Blogbeitrag

Ich habe dazu eine Feature-Anfrage auf der Developer Community-Seite geschrieben:

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

Wie Sie in den Antworten hier sehen können, gibt es viele Projekte, die versuchen, dies zu lösen, aber leider sind viele dieser Projekte Einzelentwicklerprojekte, die auf diesem Weg nicht mehr unterstützt werden. Ich denke , es wäre wirklich nett, wenn Microsoft statt eines dieser Projekte erhalten, die Schaffung eines .NETauf dem TypeScriptGenerator.

Einige werden unter anderem noch gewartet, sind jedoch stark von einem einzigen Entwickler abhängig:

TypeLite:

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

TypeScript-Definitionsgenerator:

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

Schreibmaschine:

https://github.com/frhagn/Typewriter

TypeGen:

https://github.com/jburzynski/TypeGen

Verstärkte Typisierungen:

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

Mein Tipp wäre, ein Projekt auszuwählen, von dem Sie von Anfang an erwarten, dass es nicht mehr gewartet wird, und das bereit ist, zu etwas zu wechseln, das derzeit gewartet wird. Ich würde mich für etwas entscheiden, das Anmerkungen verwendet, und die Daumen drücken. Ich könnte einfach dieses Tag durch etwas anderes ersetzen, wenn dieses Projekt nicht mehr unterstützt wird.