Key Differences Typescript and C# programming

• Language Type and Purpose:

  • TypeScript: A superset of JavaScript, designed to add static typing to JavaScript for front-end and back-end development (primarily with Node.js).
  • C#: A statically-typed, general-purpose language developed by Microsoft, used for a wide range of applications (desktop, web, games, etc.), primarily in the .NET ecosystem.

• Variable Declaration:

  • TypeScript: Uses let, const, or var for variable declarations, with optional type annotations (e.g., let name: string = "John";). Type inference allows omitting types when the value is assigned.
  • C#: Uses explicit type declarations (e.g., string name = "John";) or var for implicit typing, but the type is always resolved at compile-time. const in C# is for compile-time constants, unlike TypeScript’s const which prevents reassignment.

• Type System:

  • TypeScript: Structural typing, where compatibility is based on the shape of objects (duck typing). Supports union types (e.g., string | number), intersection types, and literal types.
  • C#: Nominal typing, where type compatibility is based on explicit inheritance or interfaces. No direct equivalent to union or intersection types; uses inheritance or interfaces for polymorphism.

• Functions:

  • TypeScript: Functions can be declared with function keyword, arrow functions (=>), or as methods in objects/classes. Supports optional/rest parameters (e.g., function fn(x?: number, ...rest: number[])). No function overloading, but supports union types for flexibility.
  • C#: Functions (methods) are typically part of classes or structs, with explicit return types. Supports method overloading, optional parameters with default values, and params for variable-length arguments.

• Classes:

  • TypeScript: Classes are similar to JavaScript ES6 classes with added type annotations. Supports public, private, protected access modifiers, but these are enforced only at compile-time. No static constructor, and abstract classes are supported.
  • C#: Classes are core to the language, with compile-time and runtime enforcement of access modifiers (public, private, protected, internal). Supports static constructors, abstract classes, and sealed classes to prevent inheritance.

• Interfaces:

  • TypeScript: Interfaces define object shapes and can be extended or merged via declaration merging. Can describe functions, arrays, and other types, with optional properties (e.g., name?: string).
  • C#: Interfaces define contracts with methods, properties, or events that implementing classes must provide. No optional members, and interfaces cannot merge declarations.

• Modules and Namespaces:

  • TypeScript: Uses ES modules (import/export) for modularity, with namespace for legacy organization. Modules resolve to JavaScript modules at runtime.
  • C#: Uses namespace to organize code and prevent naming conflicts, with assemblies for physical modularity. using directive imports namespaces, similar to TypeScript’s import but scoped to .NET’s structure.

• Generics:

  • TypeScript: Supports generics with flexible constraints (e.g., T extends SomeType). Generics are erased at runtime (type erasure).
  • C#: Supports generics with compile-time and runtime support (reified generics). Constraints are more rigid (e.g., where T : ISomeInterface).

• Nullability:

  • TypeScript: Uses null and undefined, with strict null checks enabled via strictNullChecks compiler option. Non-nullable types require explicit configuration.
  • C#: Introduced nullable reference types in C# 8.0, with ? syntax (e.g., string? name). Non-nullable reference types are default when enabled, with compile-time warnings for potential null issues.

• Access Modifiers:

  • TypeScript: Access modifiers (public, private, protected) are checked at compile-time but erased in JavaScript output, allowing runtime bypass.
  • C#: Access modifiers are enforced at both compile-time and runtime, ensuring stricter encapsulation.

• Inheritance and Polymorphism:

  • TypeScript: Supports single inheritance for classes and multiple interface implementation. No equivalent to C#’s virtual/override keywords; uses structural typing for polymorphism.
  • C#: Supports single inheritance with explicit virtual/override for method overriding and multiple interface implementation. Uses nominal typing for polymorphism.

• Error Handling:

  • TypeScript: Relies on JavaScript’s try/catch for exception handling, with no checked exceptions. Type system doesn’t enforce exception types.
  • C#: Uses try/catch/finally with strongly-typed exceptions. No checked exceptions, but exceptions are part of the type system and commonly used in .NET APIs.

• Compilation and Runtime:

  • TypeScript: Transpiles to JavaScript, running in JavaScript environments (browsers, Node.js). Types are erased at runtime, so type checks don’t affect runtime behavior.
  • C#: Compiles to Intermediate Language (IL) for the .NET runtime (CLR). Types are preserved at runtime, enabling reflection and runtime type checking.

• Tooling and Ecosystem:

  • TypeScript: Integrated with JavaScript ecosystem, using tools like npm, Webpack, and VS Code. Primarily used for web development but extensible to other environments via Node.js.
  • C#: Integrated with .NET ecosystem, using Visual Studio, MSBuild, and NuGet. Suited for enterprise applications, desktop, cloud, and game development (e.g., Unity).

• Asynchronous Programming:

  • TypeScript: Uses async/await based on JavaScript Promises, with type annotations for Promise types (e.g., Promise<string>).
  • C#: Uses async/await with Task and Task<T> for asynchronous operations, with stronger typing and integration with .NET’s threading model.

These differences highlight TypeScript’s focus on enhancing JavaScript for web development with flexible typing, versus C#’s robust, statically-typed approach for a broader range of applications in the .NET ecosystem.