TypeScript for C# Developers: Mental Model and Migration Stories

Goal: interview-ready clarity and fewer production undefined is not a function pages at 2 a.m.

Nominal vs structural typing

C# habit

Two classes with identical properties are incompatible unless explicit inheritance or interfaces with named type relationship.

TypeScript reality

If it quacks structurally, it assigns. A UserDto interface and unrelated CustomerView with same fields interchange unless you use branding tricks.

interface OrderLine { sku: string; qty: number; }
type CartItem = { sku: string; qty: number; };
const line: OrderLine = { sku: "A1", qty: 2 };
const item: CartItem = line; // OK in TS, surprising in C#

War story — fintech API portal: reused DTO types across modules; accidental structural match hid field semantic differences (amount in cents vs dollars). Fix: explicit mapper functions and distinct type aliases even when shapes match.

Interfaces, types, and C# records

TypeScript interfaces describe shapes; type aliases add unions and computed types C# expresses differently. Closest to immutable records: readonly properties plus as const for literals—not full value equality semantics.

type EnrollmentStatus = "pending" | "active" | "dropped";
interface Enrollment {
  readonly userId: string;
  readonly courseId: string;
  status: EnrollmentStatus;
}

Discriminated unions replace some polymorphism patterns—exhaustive switch with never check catches missing cases at compile time, similar to C# switch expressions.

Null, undefined, and strict mode

C# NRT catches many null issues; TypeScript strict null checks help only when enabled and when you avoid any. API JSON often omits optional fields—use optional chaining and nullish coalescing habitually.

const title = course?.metadata?.title ?? "Untitled";

LMS platform bug: backend omitted optional subtitle; frontend assumed string, called .trim() on undefined. Align OpenAPI/nullable metadata between ASP.NET Core and TypeScript generators.

Async: Task vs Promise

Surface similarity hides differences: no built-in CancellationToken propagation in browser fetch (AbortController instead), unhandled promise rejections crash nothing but fail silently in event handlers, parallel patterns use Promise.all not Task.WhenAll naming only.

E-commerce checkout story: developer ported C# retry Polly logic incorrectly—recursive async without await stack guard caused duplicate payment intent calls. Port patterns, not syntax.

Dependency injection and composition

Angular has DI container akin to ASP.NET; React relies on context, hooks, and module imports without global service locator by default. C# developers joining React e-commerce checkout team over-abstracted service classes—simplifying to hooks + plain functions improved testability.

LINQ vs array methods

.Where → filter, .Select → map, .Single → find + throw manually. TypeScript lacks query syntax; readability comes from small pure functions. Performance: avoid chaining on huge LMS grade arrays without virtualization.

Generics and erasure

Type parameters vanish at runtime—no is List<T> reflection. Pattern: factory functions and type guards narrowing unions.

function isApiError(x: unknown): x is ApiError {
  return typeof x === "object" && x !== null && "status" in x;
}

Module systems and build tooling

C# namespaces map loosely to ES modules; default vs named exports confuse imports. Read tsconfig paths like solution folders. Vite/webpack differ from dotnet build—frontend CI is its own pipeline.

Migration story: LMS platform Angular adoption

Phase 1: generate TypeScript clients from OpenAPI spec produced by ASP.NET Core. Phase 2: shared enum strings centralized. Phase 3: eslint + strict TypeScript in CI blocking any. Pain point: date strings vs Date objects—standardize ISO strings at API boundary like you would DateTimeOffset in C#.

Migration story: fintech API React dashboard

Team kept C# validation as source of truth; frontend validated only UX immediacy. Duplicated rules drifted until backend shared JSON Schema consumed by both—lesson for full-stack architects.

Testing mental shift

xUnit → Jest/Vitest; arrange-act-assert same spirit. Component tests mock HTTP differently. C# developers underestimate flaky async tests without proper await and fake timers.

AI perspective when learning TypeScript from C#

Copilot generates plausible TypeScript but overuses any and misses strict null edge cases. Prompt with "strict TypeScript, no any, discriminated unions for API errors." Verify against tsc --strict—compiler beats chat.

Interview topics linking C# and TypeScript

• Explain structural typing with example
• How ensure API contract sync between .NET and SPA
• Compare RxJS Observable to IAsyncEnumerable conceptually
• Where business logic should live in full-stack system

Two-week ramp for .NET developers

Week 1: strict TS exercises mapping C# patterns—unions, guards, async fetch. Week 2: build read-only LMS catalog consuming your Web API with typed client and error boundary. Pair with Angular or React course module on Toolliyo matching employer stack.

Common phrases to unlearn

• "I'll add interface later" — types are design, not decoration
• "Frontend will validate" — duplicate or generate from single schema
• "It's just JavaScript" — strict TS is a different language discipline

TypeScript for C# developers succeeds when you remap types, nullability, and runtime erasure honestly—not when you paste C# class names into .tsx files. Migration stories from LMS, fintech, and e-commerce teams prove the backend engineer who learns structural thinking ships full-stack features interviewers believe.