TypeScript im Alltag
Klassen, Generics, Union-Typen, Dekoratoren, Module, async/await und moderne Typsystemfunktionen werden in SharpTS-Workflows unterstützt.
Ein TypeScript-Interpreter und AOT-Compiler für .NET
Führen Sie es als Skript für sofortiges Feedback aus oder kompilieren Sie es zu einer nativen .NET-Assembly — mit vollem Zugriff auf das .NET-Ökosystem.
curl -fsSL https://sharpts.dev/setup.sh | shirm https://sharpts.dev/setup.ps1 | iex// Führen Sie TypeScript direkt auf .NET aus
interface Greeter {
greet(name: string): string;
}
class WelcomeBot implements Greeter {
constructor(private prefix: string) {}
greet(name: string): string {
return `${this.prefix}, ${name}! Welcome to SharpTS.`;
}
}
const bot = new WelcomeBot("Hello");
console.log(bot.greet("Developer"));
// → Hello, Developer! Welcome to SharpTS.Schreiben Sie TypeScript, das auf der .NET-Laufzeit läuft — interpretiert für schnelle Iteration oder kompiliert zu nativen .NET-Assemblys.
Richten Sie SharpTS auf eine .ts-Datei, und sie läuft — ohne Build-Schritt, ohne Konfiguration. Ideal für Skripte, Automatisierung und das Ausprobieren von Ideen in der REPL.
Vorzeitige Kompilierung zu einer echten .NET-Assembly — einer DLL, einer eigenständigen ausführbaren Datei oder einem NuGet-Paket — mit nativer CLR-Geschwindigkeit.
Rufen Sie .NET-Bibliotheken aus TypeScript mit @DotNetType auf und nutzen Sie Ihr kompiliertes TypeScript aus C#. Verwenden Sie die BCL, NuGet-Pakete und vorhandenen Code weiter.
Verwenden Sie vertrautes TypeScript — Generics, Klassen, Dekoratoren, Async, Module und mehr — mit Typprüfung vor der Ausführung. Den praktischen Kompatibilitätsüberblick finden Sie weiter unten.
Fügen Sie das SharpTS.Sdk zu einem .NET-Projekt hinzu, und dotnet build kompiliert Ihr TypeScript zusammen mit Ihrem C# — dieselbe Toolchain, dasselbe Ergebnis.
Ein Language Server bringt Autovervollständigung, Typprüfung und „Gehe zu Definition“ in VS Code und Visual Studio.
Echtes TypeScript, ausgeführt auf der .NET-Laufzeit
const greeting: string = "Hello from SharpTS!";
const version: number = 1.0;
console.log(`${greeting} v${version}`);
const languages = ["TypeScript", "C#", ".NET"];
languages.forEach(lang => console.log(` ✓ ${lang}`));Hello from SharpTS! v1 ✓ TypeScript ✓ C# ✓ .NET
interface Comparable<T> { compareTo(other: T): number; }
class Temperature implements Comparable<Temperature> {
constructor(private celsius: number) {}
get fahrenheit(): number { return this.celsius * 9 / 5 + 32; }
compareTo(other: Temperature): number { return this.celsius - other.celsius; }
toString(): string { return `${this.celsius}°C (${this.fahrenheit}°F)`; }
}
const temps = [new Temperature(100), new Temperature(0), new Temperature(37)];
temps.sort((a, b) => a.compareTo(b));
temps.forEach(t => console.log(t.toString()));0°C (32°F) 37°C (98.6°F) 100°C (212°F)
async function delay(ms: number): Promise<string> { return `Done after ${ms}ms`; }
async function main() {
console.log(await delay(100));
const all = await Promise.all([delay(50), delay(100), delay(150)]);
all.forEach(result => console.log(result));
}
main();Done after 100ms Done after 50ms Done after 100ms Done after 150ms
const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const result = data.filter(n => n % 2 === 0).map(n => n ** 2).reduce((sum, n) => sum + n, 0);
console.log(`Sum of squares of evens: ${result}`);
const [first, second, ...rest] = data;
console.log(`First: ${first}, Second: ${second}`);
console.log(`Rest: [${rest.join(", ")}]`);Sum of squares of evens: 220 First: 1, Second: 2 Rest: [3, 4, 5, 6, 7, 8, 9, 10]
console.log(`PI = ${Math.PI}`);
console.log(`E = ${Math.E}`);
console.log(`sqrt(144) = ${Math.sqrt(144)}`);
const now = new Date("2026-03-02T12:00:00.000Z");
console.log(`ISO: ${now.toISOString()}`);
const obj = { name: "SharpTS", nums: [1, 2, 3] };
console.log(`JSON: ${JSON.stringify(obj)}`);PI = 3.141592653589793
E = 2.718281828459045
sqrt(144) = 12
ISO: 2026-03-02T12:00:00.000Z
JSON: {"name":"SharpTS","nums":[1,2,3]}// Full CLI interop (the public playground intentionally disables module loading)
@DotNetType("System.Text.StringBuilder")
declare class StringBuilder {
constructor();
append(value: string): StringBuilder;
toString(): string;
}
@DotNetType("System.TimeSpan")
declare class TimeSpan {
static fromHours(value: number): TimeSpan;
readonly totalMinutes: number;
}
const sb = new StringBuilder();
sb.append("1.5 hours = ");
sb.append(`${TimeSpan.fromHours(1.5).totalMinutes} minutes`);
console.log(sb.toString());1.5 hours = 90 minutes
Konkrete Situationen, in denen TypeScript auf .NET die bessere Wahl ist als Node — oder als C#.
Schreiben Sie Build-Skripte, Entwickler-Tools und einmalige Automatisierung in TypeScript mit der gesamten BCL — auf Maschinen, die bereits das .NET SDK haben und keine Node-Toolchain. Kein package.json, kein Build-Schritt: Richten Sie sharpts auf die Datei.
sharpts rotate-logs.tsKompilieren Sie ein TypeScript-Modul zu einer echten Assembly und veröffentlichen Sie es als versioniertes NuGet-Paket. Mit einer Referenz-Assembly instanziieren C#-Aufrufer Ihre Klassen und rufen Ihre Methoden vollständig typisiert auf.
sharpts --compile pricing.ts --ref-asm
sharpts --compile pricing.ts --packLassen Sie Kolleginnen und Kollegen mit TypeScript-Hintergrund in der Sprache beitragen, die sie am besten kennen. Mit dem SharpTS.Sdk werden ihre .ts-Dateien im selben dotnet build kompiliert wie die C#-Projekte drumherum — eine Toolchain, eine CI-Pipeline.
<Project Sdk="SharpTS.Sdk/1.0.0">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<SharpTSEntryPoint>src/main.ts</SharpTSEntryPoint>
</PropertyGroup>
</Project>Kompilieren Sie zu einer einzigen eigenständigen ausführbaren Datei, die ohne separate Laufzeitinstallation läuft — kein Node auf der Zielmaschine, kein node_modules-Ordner neben Ihrem Tool.
sharpts --compile tool.ts -t exe
./toolEine mehrstufige Pipeline vom Quellcode bis zur Ausführung
Schreiben Sie TypeScript und führen Sie es auf .NET aus — direkt in Ihrem Browser
Ein praktischer Überblick über die heute verfügbaren TypeScript- und Laufzeitfunktionen. Messbare Details finden Sie unter Konformität.
Klassen, Generics, Union-Typen, Dekoratoren, Module, async/await und moderne Typsystemfunktionen werden in SharpTS-Workflows unterstützt.
Gängige APIs für Array, String, Collections, Promise, Date, RegExp, JSON, Symbol und typisierte Arrays sind verfügbar.
Importe ohne Pfad sowie die exports/imports-Felder von Paketen können aufgelöst werden, Pakete benötigen aber weiterhin SharpTS-kompatible Syntax und Laufzeit-APIs. Pakete mit TypeScript-Quellcode eignen sich am besten.
Proxy und WeakRef sind nicht implementiert. Bei Grenzfällen der Spezifikation können sich die Ergebnisse von Interpreter und AOT ebenfalls unterscheiden.
Die Fragen, die zuerst kommen — direkt beantwortet.
tsc prüft die Typen Ihres Codes und erzeugt JavaScript, das eine Engine wie Node ausführt. SharpTS erzeugt nie JavaScript: Es prüft dasselbe TypeScript und führt es dann entweder direkt aus oder kompiliert es zu einer .NET-Assembly. Nirgendwo in der Kette steckt Node. Das Setup-Skript verwendet das .NET SDK, wenn es verfügbar ist, oder installiert andernfalls eine eigenständige Variante.
Diese Projekte führen reines, untypisiertes JavaScript in einem .NET-Host aus — gut geeignet für kleine eingebettete Skripte. SharpTS führt TypeScript selbst aus, typgeprüft vor der Ausführung, und bietet, was eine eingebettete JS-Engine nicht kann: vorzeitige Kompilierung zu IL, NuGet-Paketierung und typisierte Interop in beide Richtungen zwischen TypeScript und C#.
Teilweise. Importe ohne Pfad werden über node_modules aufgelöst; unterstützte Modulauflösungsmodi können außerdem die exports/imports-Felder und bedingte Ziele von Paketen anwenden. Pakete können dennoch scheitern, wenn sie nicht unterstützte Syntax, native Add-ons, Browser-Globals oder fehlende Laufzeit-APIs voraussetzen. Pakete mit TypeScript-Quellcode eignen sich am besten.
Zur Node.js-Kompatibilitätsübersicht →Jeder Modus antwortet anders. Der Interpreter durchläuft den Syntaxbaum und ist auf sofortigen Start ausgelegt — richtig für Skripte und die REPL, nicht für Zahlenakrobatik. Der kompilierte Modus erzeugt IL, das der CLR-JIT wie jede C#-Assembly kompiliert: Es läuft als nativer .NET-Code. In beiden Modi werden die Typen vorab geprüft und dann entfernt — zur Laufzeit kosten sie nichts.
SharpTS ist ein junges, MIT-lizenziertes Projekt in aktiver Entwicklung. Der Kompatibilitätsüberblick oben fasst gängige Funktionen zusammen, die gemessene Konformität liefert detaillierte Nachweise und STATUS.md verfolgt Implementierungslücken.
Fortschritt in STATUS.md verfolgen →In drei Schritten einsatzbereit
Führen Sie das Setup-Skript aus, um die passende SharpTS-Variante für diesen Rechner zu installieren
curl -fsSL https://sharpts.dev/setup.sh | shirm https://sharpts.dev/setup.ps1 | iexErstellen Sie eine TypeScript-Datei
interface Config {
name: string;
debug: boolean;
}
const config: Config = { name: "MyApp", debug: true };
console.log(`Starting ${config.name}...`);Direkt interpretieren oder zu einer .NET-Assembly kompilieren
# Interpretieren (sofortiger Start)
sharpts hello.ts
# Zu einer .NET-Assembly kompilieren
sharpts --compile hello.ts -o hello