Let’s dive into a detailed comparison of TypeScript interfaces and C# interfaces, focusing on their roles, capabilities, and differences as described in the statement. I’ll provide clear examples to illustrate how TypeScript interfaces define flexible object shapes with features like declaration merging and optional properties, while C# interfaces enforce strict contracts without optional members or merging. The comparison will cover their syntax, use cases, and key differences in a structured, pointwise manner with examples.

TypeScript: Interfaces

TypeScript interfaces are primarily used to define the shape of objects, leveraging structural typing (duck typing) to ensure compatibility based on structure rather than explicit inheritance. They are highly flexible, supporting optional properties, declaration merging, and the ability to describe not only objects but also functions, arrays, and other types. Since TypeScript compiles to JavaScript, interfaces are erased at runtime and exist only for compile-time type checking.

1. Defining Object Shapes

TypeScript interfaces describe the structure of an object, including its properties and their types. Properties can be optional using the ? syntax.

• Example:

  interface Person {
      name: string;
      age?: number; // Optional property
      greet(): string;
  }
   
  const person: Person = {
      name: "Alice",
      greet: () => "Hello, I'm Alice!"
  }; // Valid: 'age' is optional
  console.log(person.greet()); // Output: Hello, I'm Alice!

2. Optional Properties

Optional properties allow objects to omit certain fields without causing type errors, making interfaces flexible for partial implementations.

• Example:

  interface Car {
      make: string;
      model?: string; // Optional
      year?: number; // Optional
  }
   
  const car1: Car = { make: "Toyota" }; // Valid: optional properties omitted
  const car2: Car = { make: "Honda", model: "Civic", year: 2020 }; // Valid: all properties provided
  console.log(car1.make); // Output: Toyota
  console.log(car2.model); // Output: Civic

3. Declaration Merging

TypeScript allows multiple declarations of the same interface name to be merged automatically, combining their properties. This is useful for extending existing interfaces, especially in modular code or when augmenting third-party libraries.

• Example:

  interface User {
      name: string;
  }
   
  // Declaration merging
  interface User {
      email: string;
  }
   
  const user: User = {
      name: "Bob",
      email: "bob@example.com"
  }; // Valid: interface includes both 'name' and 'email'
  console.log(user); // Output: { name: "Bob", email: "bob@example.com" }

4. Extending Interfaces

Interfaces can extend other interfaces using the extends keyword, inheriting their properties and methods.

• Example:

  interface Animal {
      species: string;
      move(): string;
  }
   
  interface Dog extends Animal {
      bark(): string;
  }
   
  const dog: Dog = {
      species: "Canine",
      move: () => "Running...",
      bark: () => "Woof!"
  };
  console.log(dog.bark()); // Output: Woof!
  console.log(dog.move()); // Output: Running...

5. Describing Functions, Arrays, and Other Types

TypeScript interfaces can describe more than just objects, such as function signatures, indexable types (arrays or dictionaries), and even hybrid types.

• Function Type Example:

  interface GreetFunction {
      (name: string): string; // Describes a function signature
  }
   
  const greet: GreetFunction = (name) => `Hello, ${name}!`;
  console.log(greet("Alice")); // Output: Hello, Alice!
• Indexable Type (Array-like or Dictionary) Example:

  interface StringArray {
      [index: number]: string; // Describes an array-like structure
  }
   
  const names: StringArray = ["Alice", "Bob"];
  console.log(names[0]); // Output: Alice
   
  interface Dictionary {
      [key: string]: number; // Describes a key-value object
  }
   
  const scores: Dictionary = { Alice: 90, Bob: 85 };
  console.log(scores["Alice"]); // Output: 90

6. Compile-Time Only

Interfaces in TypeScript exist only for type checking during compilation. They are erased in the generated JavaScript, so they have no runtime impact.

• Example:

  interface Point {
      x: number;
      y: number;
  }
   
  const point: Point = { x: 10, y: 20 };
  // Compiles to plain JavaScript:
  // const point = { x: 10, y: 20 };

C#: Interfaces

C# interfaces define contracts that implementing classes must adhere to, specifying methods, properties, or events. They are part of C#’s nominal typing system, meaning compatibility is based on explicit interface implementation rather than structure. C# interfaces are stricter, with no optional members or declaration merging, and they are enforced at both compile-time and runtime in the .NET ecosystem.

1. Defining Contracts

C# interfaces specify methods, properties, indexers, or events that implementing classes must provide. All members are implicitly public and must be implemented explicitly.

• Example:

  public interface IPerson
  {
      string Name { get; set; }
      string Greet();
  }
   
  public class Person : IPerson
  {
      public string Name { get; set; }
   
      public Person(string name)
      {
          Name = name;
      }
   
      public string Greet()
      {
          return $"Hello, I'm {Name}!";
      }
  }
   
  class Program
  {
      static void Main()
      {
          IPerson person = new Person("Alice");
          Console.WriteLine(person.Greet()); // Output: Hello, I'm Alice!
      }
  }

2. No Optional Members

C# interfaces require all members to be implemented by the implementing class. There is no concept of optional properties or methods.

• Example:

  public interface IVehicle
  {
      string Make { get; }
      string Model { get; } // Must be implemented
      int Year { get; }   // Must be implemented
  }
   
  public class Car : IVehicle
  {
      public string Make { get; }
      public string Model { get; }
      public int Year { get; }
   
      public Car(string make, string model, int year)
      {
          Make = make;
          Model = model;
          Year = year;
      }
  }
   
  class Program
  {
      static void Main()
      {
          IVehicle car = new Car("Toyota", "Camry", 2020);
          Console.WriteLine($"{car.Make} {car.Model} {car.Year}"); // Output: Toyota Camry 2020
      }
  }
  • Note: If Car omitted any of Make, Model, or Year, the compiler would throw an error.

3. No Declaration Merging

C# interfaces cannot be declared multiple times with the same name to merge properties. Each interface is a single, distinct declaration, and redeclaring an interface with the same name in the same namespace causes a compiler error.

• Example:

  public interface IUser
  {
      string Name { get; }
  }
   
  // This would cause a compiler error:
  // public interface IUser
  // {
  //     string Email { get; }
  // }
  To add more members, you must extend an interface or create a new one.

4. Extending Interfaces

C# interfaces can inherit from other interfaces using the : syntax, requiring implementing classes to provide all members from both the base and derived interfaces.

• Example:

  public interface IAnimal
  {
      string Species { get; }
      string Move();
  }
   
  public interface IDog : IAnimal
  {
      string Bark();
  }
   
  public class Dog : IDog
  {
      public string Species { get; }
      public Dog(string species)
      {
          Species = species;
      }
   
      public string Move()
      {
          return "Running...";
      }
   
      public string Bark()
      {
          return "Woof!";
      }
  }
   
  class Program
  {
      static void Main()
      {
          IDog dog = new Dog("Canine");
          Console.WriteLine(dog.Bark()); // Output: Woof!
          Console.WriteLine(dog.Move()); // Output: Running...
      }
  }

5. Support for Properties, Indexers, and Events

C# interfaces can define properties, indexers, and events, making them versatile for defining complex contracts.

• Indexer Example:

  public interface IStringList
  {
      string this[int index] { get; set; } // Indexer
      int Count { get; }
  }
   
  public class StringList : IStringList
  {
      private string[] items = new string[10];
   
      public string this[int index]
      {
          get => items[index];
          set => items[index] = value;
      }
   
      public int Count => items.Length;
  }
   
  class Program
  {
      static void Main()
      {
          IStringList list = new StringList();
          list[0] = "Apple";
          Console.WriteLine(list[0]); // Output: Apple
          Console.WriteLine(list.Count); // Output: 10
      }
  }
• Event Example:

  public interface INotifier
  {
      event EventHandler<string> OnNotify; // Event
  }
   
  public class Notifier : INotifier
  {
      public event EventHandler<string> OnNotify;
   
      public void Notify(string message)
      {
          OnNotify?.Invoke(this, message);
      }
  }
   
  class Program
  {
      static void Main()
      {
          INotifier notifier = new Notifier();
          notifier.OnNotify += (sender, message) => Console.WriteLine(message);
          notifier.Notify("Test message"); // Output: Test message
      }
  }

6. Compile-Time and Runtime Enforcement

C# interfaces are enforced at both compile-time and runtime, as they are part of the .NET type system. Classes must explicitly declare that they implement an interface, and runtime type checking (e.g., via is or as) is supported.

• Example:

  IPerson person = new Person("Bob");
  Console.WriteLine(person is IPerson); // Output: True

Key Differences Summarized with Examples

1. Purpose and Typing:

   • TypeScript: Interfaces define object shapes using structural typing, allowing flexibility for objects that match the shape without explicit implementation.

     interface Point {
         x: number;
         y: number;
     }
     const point = { x: 1, y: 2, z: 3 }; // Valid: extra properties allowed
     const p: Point = point; // Structural typing
   • C#: Interfaces define strict contracts using nominal typing, requiring explicit implementation.

     public interface IPoint
     {
         int X { get; }
         int Y { get; }
     }
     public class Point : IPoint
     {
         public int X { get; }
         public int Y { get; }
         public Point(int x, int y) { X = x; Y = y; }
     }
     // IPoint p = { X = 1, Y = 2 }; // Error: Must be an instance of a class implementing IPoint

2. Optional Members:

   • TypeScript: Supports optional properties for flexibility.

     interface User {
         name: string;
         email?: string;
     }
     const user: User = { name: "Alice" }; // Valid
   • C#: No optional members; all interface members must be implemented.

     public interface IUser
     {
         string Name { get; }
         string Email { get; }
     }
     public class User : IUser
     {
         public string Name { get; }
         public string Email { get; } // Must implement Email
         public User(string name, string email) { Name = name; Email = email; }
     }

3. Declaration Merging:

   • TypeScript: Supports declaration merging to combine multiple interface declarations.

     interface Config {
         host: string;
     }
     interface Config {
         port: number;
     }
     const config: Config = { host: "localhost", port: 8080 }; // Valid
   • C#: No declaration merging; redeclaring an interface causes a compiler error.

     public interface IConfig
     {
         string Host { get; }
     }
     // public interface IConfig { int Port { get; } } // Error: Duplicate interface

4. Extending Interfaces:

   • TypeScript: Uses extends for interface inheritance, with flexible structural typing.

     interface A { x: number; }
     interface B extends A { y: number; }
     const b: B = { x: 1, y: 2 };
   • C#: Uses : for interface inheritance, with explicit implementation.

     public interface IA { int X { get; } }
     public interface IB : IA { int Y { get; } }
     public class MyClass : IB
     {
         public int X { get; }
         public int Y { get; }
         public MyClass(int x, int y) { X = x; Y = y; }
     }

5. Describing Non-Object Types:

   • TypeScript: Can describe functions, arrays, and indexable types.

     interface Func { (x: number): number; }
     const double: Func = x => x * 2;
   • C#: Limited to methods, properties, indexers, and events; function types are handled via delegates.

     public delegate int Func(int x); // Delegate for function type
     public class MyClass
     {
         public static int Double(int x) => x * 2;
     }
     Func func = MyClass.Double;

6. Runtime Behavior:

   • TypeScript: Interfaces are erased at runtime, existing only for compile-time checks.

     interface X { prop: string; }
     const x: X = { prop: "test" };
     // No runtime interface info
   • C#: Interfaces are part of the .NET type system, with runtime support.

     public interface IX { string Prop { get; } }
     public class MyClass : IX { public string Prop => "test"; }
     IX x = new MyClass();
     Console.WriteLine(x is IX); // Output: True

Summary

• TypeScript Interfaces: Designed for flexibility in JavaScript environments, they define object shapes with optional properties, declaration merging, and the ability to describe functions, arrays, and more. They rely on structural typing and exist only at compile-time, making them ideal for dynamic, web-based applications.
• C# Interfaces: Define strict contracts in the .NET ecosystem, requiring explicit implementation of all members (no optional members) and supporting methods, properties, indexers, and events. They use nominal typing, are enforced at both compile-time and runtime, and do not support declaration merging, making them suited for strongly-typed, enterprise-grade applications.

These differences reflect TypeScript’s role in enhancing JavaScript’s dynamic nature with type safety, versus C#’s focus on rigid, enforceable contracts in a statically-typed, object-oriented framework.