TypeScript projelerinde mevcut C # sınıfı tanımları nasıl yeniden kullanılır?

Ben sadece, TypeScriptzaten var olan bir varlık çerçeve etki alanı modeline sahip bir MVC projesine ait olan HTML istemci projemde kullanmaya başlayacağım . İki projemin (istemci tarafı ve sunucu tarafı) tamamen ayrı olmasını istiyorum, çünkü iki ekip bu konuda çalışacak ... JSON ve REST, nesneleri ileri geri iletmek için kullanılır.

Tabii ki, domainistemci tarafındaki nesnelerim sunucu tarafındaki nesnelerle eşleşmelidir. Geçmişte bunu normalde manuel olarak yaptım. POJOTypeScript "de karşılık gelen sınıfları oluşturmak için C # sınıfı tanımlarımı (özellikle etki alanı modelimdeki sınıfları) yeniden kullanmanın bir yolu var mı ?

Şu anda C # 'ı TypeScript ile eşleştirecek hiçbir şey yok. Çok sayıda POCO'nuz varsa veya bunların sık sık değişebileceğini düşünüyorsanız, bir dönüştürücü yaratabilirsiniz - basit bir şey ...

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

için

export class MyPoco {
    public Name: string;
}

C # 'dan otomatik oluşturma hakkında Codeplex hakkında bir tartışma da var .

TypeLite, işleri güncel tutmak için C # 'dan TypeScript arayüzleri oluşturabilir:

http://type.litesolutions.net/

Web Essentials , kayıt sırasında C # dosyalarını TypeScript .d.tsdosyalarına derlemeye izin verir . Daha sonra .tsdosyalarınızdan tanımlara başvurabilirsiniz.

TypeLite ve T4TS'lerin her ikisi de iyi görünüyordu, sadece birini seçti, TypeLite, destek almak için çatalladı

• ValueTypes ,
• Nullables
• camelCasing (typescript kök doc develer kullanır ve bu C # ile çok güzel buluşmanızı gider)
• ortak alanlar (temiz ve okunabilir POCO'ları sever, ayrıca C # Derleyicisini kolaylaştırır)
• modül oluşturmayı devre dışı bırak

Sonra C # arayüzlerine ihtiyacım vardı ve kendi işimi yapma zamanının geldiğini düşündüm ve ihtiyacım olanı yapan basit bir T4 betiği yazdım. Ayrıca Enums içerir . Depoya gerek yok, sadece <100 satır T4.

Kullanım
Kitaplık yok, NuGet yok, yalnızca bu basit T4 dosyası - Visual Studio'da "öğe ekle" yi kullanın ve herhangi bir T4 şablonunu seçin. Ardından bunu dosyaya yapıştırın. Her satırı içinde "ACME" ile uyarlayın. Her C # sınıfı için bir satır ekleyin

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

Sırayla önemli, bilinen herhangi bir tür aşağıdaki arayüzlerde kullanılacaktır. Yalnızca arabirimler kullanıyorsanız, dosya uzantısı .d.ts olabilir, numaralandırmalar için bir .ts dosyasına ihtiyacınız vardır , çünkü bir değişken başlatılır.

Özelleştirme
Komut dosyasını hackleyin.

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

Komut dosyasının bir sonraki seviyesi, MVC JsonController sınıfından servis arayüzünü oluşturmak olacaktır.

Vscode kullanıyorsanız , tam olarak bunu yapan csharp2ts uzantımı kullanabilirsiniz .

Yapıştırılan C # kodunu seçmeniz ve Convert C# to TypeScriptkomut paletinden komutu çalıştırmanız yeterlidir. Bir dönüştürme örneği:

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

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

için

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

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

Visual Studio kullanıyorsanız, Typewriter uzantısını ekleyin.

Visual Studio Galerisi

Web sitesi / Belgeler

Güncelleme

VS 2015'te yüklenen Web Essentials ile , sınıf dosyasını sağ tıklayıp, ardından bağlam menüsünden> Web Essentials> TypeScript Intellisense Dosyası Oluştur'u tıklayabilirsiniz.

İşte onu çözme yaklaşımım. C # sınıflarınızı bir öznitelikle bildirin ve .d.ts dosyaları oluşturulacaktır (T4 dönüşümleri kullanılarak). Nuget'ta bir paket var ve kaynak github'da mevcut . Hala proje üzerinde çalışıyorum, ancak destek oldukça kapsamlı.

Reinforced.Typings çerçevesini deneyin. Sorununuzu çözüyor gibi görünüyor.

1. NuGet'ten yükleyin

2. POCO'nuza gidin ve [TsInterface]üstüne nitelik ekleyin

   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. Projenizi yeniden oluşturun

4. Oluşturulan TypeScript kodunu %Your_Project_Directory%/Scripts/project.tsdosyada bulun ve manuel olarak projeye ekleyin

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

5. Tüm POCO'larınız için aynısını yapın ve project.tsdiğer TypeScript kodunuzdaki referans .

Belgeler wiki'sinde daha fazla ayrıntı görün

C # sınıflarından TypeScript arabirimleri oluşturabilen küçük bir yardımcı program oluşturdum. NuGet paketi olarak mevcuttur . Ayrıntılı dokümantasyon proje web sayfasında bulunabilir .

Lütfen bu kütüphaneye bir göz atın Daktilo

Yalnızca sınıfları, numaralandırmaları, arabirimleri vb. Dönüştürmez, aynı zamanda api denetleyicilerini de dönüştürür, bu da harika bir şeydir.

Ayrıca, siz kaynak .cs dosyasını kaydeder kaydetmez bunu yapar, böylece herhangi bir harici aracı tetiklememe gerek kalmaz. .Cs kaydedin ve .ts güncellemesini alın

T4 şablonlarını kullanan küçük bir çözümüm var ( kaynağı görüntüle ).

Herhangi bir CLR POCO'dan gidersiniz:

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

TypeScript arayüzüne:

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

Açık kaynaklı NSwag projesini kullanabilirsiniz : GUI'de, mevcut bir .NET DLL'den .NET sınıfını seçebilir ve bunun için TypeScript arabirimini oluşturabilirsiniz.

Proje ayrıca T4 şablonları için komut satırı araçları ve desteğinin yanı sıra Web API denetleyicileri için istemci kodunun oluşturulmasını sağlar ...

Üretilen her TypeScript sınıfı / arabirimi için ayrı bir dosya oluşturmanız gerekiyorsa (yani, "dosya başına tek bir sınıf" biçiminde), TypeGen'i deneyebilirsiniz . C # sınıflarınıza / numaralarınıza dayalı olarak TypeScript dosyaları oluşturmak için Paket Yöneticisi Konsolundan kullanabileceğiniz bir araçtır. Şu anda şunları desteklemektedir:

• numaralandırmaları dışa aktarma; POCO'ları TS sınıfları veya arayüzleri olarak dışa aktarma
• miras
• genel türler
• koleksiyon / iç içe geçmiş koleksiyon türleri

artı bazı ek özellikler. Aynı zamanda açık kaynaklıdır ( github'da kontrol edebilirsiniz ).

Peki ya tam tersi?

Erecruit TypeScript Translator'a göz atın . Kullanıma hazır C # desteği ile birlikte gelir, ancak aslında şablon tabanlıdır (oluşturma için Nunjucks kullanır), bu da başka her şeyi oluşturabileceği anlamına gelir - VB.NET, F #, C ++, XML, SQL - bir şablonla kodlayabileceğiniz her şeyi.

Bir .NET konsol programı, NodeJS programı (Windows'ta olmayanlar için) veya bir Visual Studio uzantısı olarak çalışır , kaydetme üzerine oluştur işleviyle tamamlanır. Ayrıca, derleme sunucunuzu mutlu etmek için MSBuild desteği içerir. :-)

Bunu da kullanabilirsiniz: https://github.com/pankleks/TypeScriptBuilder

Bu küçük kitaplık, C # türlerine göre TypeScript türü tanımı oluşturur. Ön uç TypeScript projeniz için kod oluşturmak üzere doğrudan arka uç C # projenizde kullanın. Önceden oluşturulmuş araçlarla kod oluşturmak için küçük konsol uygulaması da yazabilirsiniz.

Full & NET Core çerçevesi üzerinde çalışır!

NuGet tarafından yükleyin: Install-Package TypeScriptBuilder

Desteklenen özellikler

• Tür bağımlılığını çözme
• Jenerik
• Tür mirası
• Ad alanları (modüller)
• Sıralamalar
• Null yapılabilir türler
• Sözlük yakınsaması (güçlü tip TS dizinli nesnelere)
• Kod oluşturma kontrol öznitelikleri kümesi
• any dönüştürülemeyen türler için

Daha fazla açıklama: https://github.com/pankleks/TypeScriptBuilder/blob/master/README.md

Çocuklar https://github.com/reinforced/ Reinforced.Typings'e bir göz attılar . Son birkaç gündür typelite ve t4 şablonlarıyla oynuyorum ve bu projeyle son buldum. Çok basit ve bir cazibe gibi çalışıyor. Sadece paketi alın, yapılandırma dosyasını değiştirin (10 saniye gibi) ve oluşturun. Hepsi herhangi bir sorun olmadan otomatik olarak yapılır. Yazarı korusun!

T4 şablonlarıyla ilgili kötü olan şey, VS'den derlediğinizde taranan derlemelerin kilitlenmesi ve VS'yi yeniden başlatmanız gerektiğidir (bu ne kadar aptalca?). T4 Toolbox + bazı VS temizleme direktiflerinde bazı geçici çözümler var, ancak bunların hiçbiri benim için işe yaramadı.

Citykid çözümünü beğendim. Biraz uzatmıştım. Bu nedenle çözüm, T4 şablonlarıyla kod oluşturma tekniğine de dayanmaktadır.

Yaygın TypeScript türleri ve ortam bildirimleri oluşturabilir.

Devralma ve arayüz uygulamalarını destekler.

Tür alanları olarak jenerikleri, dizileri ve listeleri destekler.

Ayrıca, konfigürasyonda açıkça belirtilmeyen TypeScript türlerini de çevirir (örneğin, A tipini içe aktarırız ve TS çıktısında başka türler de bulabilirsiniz: alan türleri, temel türler ve arabirimler).

Ayrıca türün adını geçersiz kılabilirsiniz.

Numaralandırmalar da desteklenmektedir.

Kullanım örneği (bunu proje havuzunda bulabilirsiniz):

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

Ve bir çıktı alacaksın

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

Tam çözümü buradan kontrol edin: https://bitbucket.org/chandrush/cst4ts

Bridge.net'i de kullanabilirsiniz. 1.7 sürümünden itibaren C # türleri için TypeScript tanımlarının oluşturulmasını destekler. Bkz. Http://bridge.net/docs/generate-typescript-definitions/

@ Citykid'in cevabını da çok beğendim, bu yüzden her seferinde bütün bir isim alanını kapsayacak şekilde genişlettim. Sadece POCO sınıflarını ad alanına yerleştirin ve T4 şablonlarını yeniden oluşturun. Keşke her biri için ayrı dosyaların nasıl oluşturulacağını bilseydim, ama bu dünyanın sonu değil.

Üst kısımdaki (istediğiniz sınıfların bulunduğu) .DLL dosyalarına başvurmanız ve ad alanlarından bahsetmeniz gerekir. Düzenlenecek tüm satırlar ACME ile işaretlenmiştir. @Citykid'e büyük tatlılar, takdir et!

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

Benim çözümüm, basitçe bir proje derlemesini alan (ve derlemeleri başvuran) küçük bir kod oluşturucu kullanımı yazmak ve typcript ve c # arasındaki etkileşimde yer alan türleri taramaya başlamaktı. Bu kullanım, hem javascript'i d.ts olarak çıkarır ... Araç, inşa sonrası olayında çağrılır ... bir cazibe gibi çalışır!

İlgileniyorsanız, TypedRpc'yi kullanabilirsiniz . Amacı, arabirimleri yalnızca TypeScript'te oluşturmak değil, JsonRpc protokolünü kullanarak .Net'te hizmetle tüm iletişimi oluşturmaktır.

Sunucudaki bir sınıf için örnek:

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

Üretilen TypeScript kodunun kullanımı:

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

Check out https://github.com/Rodris/TypedRpc nasıl kullanılacağını diğer örnekler için.

ASP.NET Web API İstemci Oluşturucuları , SDLC sırasında havalı araç zincirinden ve diğerlerinden daha kullanışlı, daha az ek yük olabilir.

Programcılar genellikle istemci API kodları oluşturmak için WebApiClientGen'i kullanırken, bu proje aynı zamanda POCO sınıflarından TypsScript arayüzleri oluşturan bir komut satırı programı olan POCO2TS.exe'yi de sağlar. Kod oluşturmayı derleme ardışık düzeninizle tümleştirmek için Poco2ts.exe veya poco2ts bileşenini kullanabilirsiniz.

Bunu node.js aracılığıyla dönüştürmek istiyorsanız, bu paketi kullanabilirsiniz (csharp-to-typescript). https://www.npmjs.com/package/csharp-to-typescript

kaynak kodu: 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 kullanıyorsanız, o uzantı C # ile TypeScript'e bir göz atabilirsiniz.

Sadece bir tıklamayla onu C # kodundan nasıl dönüştürebileceğimi görün. Tabii ki, fabrika gibi tüm sınıflar dönüştürülmeyecek, ancak müşteri tarafı için yeterince iyi. Sadece verilerin şekline ihtiyacımız var. Bazen ziyaretçi kalıbını kullanmam gerekirse, ihtiyacım olan ek yöntemlerle dekorasyon yapacağım. Bunu yapmak sadece 5 saniye sürdü. Yukarıdaki bir dakika ile karşılaştırıldığında, bunun büyük bir kazanç olduğunu söyleyebilirim.

Blog gönderimde daha fazla ayrıntı görün