c# - array - ¿Qué es la "escritura estructural para interfaces" en TypeScript

typescript type object

Question

En su publicación del blog sobre TypeScript, Mark Rendle dice que una de las cosas que le gustan de esto es:

"Tipificación estructural para interfaces. Realmente deseo que C # pueda hacer eso"

Que quiso decir con eso?

Answer 1

Básicamente, significa que las interfaces se comparan en una base de "tipificación de pato" en lugar de una identidad de tipo.

Considere el siguiente código C #:

interface X1 { string Name { get; } }
interface X2 { string Name { get; } }
// ... later
X1 a = null;
X2 b = a; // Compile error! X1 and X2 are not compatible

Y el código equivalente de TypeScript:

interface X1 { name: string; }
interface X2 { name: string; }
var a: X1 = null;
var b: X2 = a; // OK: X1 and X2 have the same members, so they are compatible

La especificación no cubre esto con mucho detalle, pero las clases tienen "marcas", lo que significa que el mismo código, escrito con clases en lugar de interfaces, tendría un error. Las interfaces C # tienen marcas y, por lo tanto, no se pueden convertir implícitamente.

La forma más sencilla de pensarlo es que si está intentando realizar una conversión de la interfaz X a la interfaz Y, si X tiene todos los miembros de Y, la conversión será satisfactoria, aunque X e Y no tengan los mismos nombres.

Answer 2

Pensar en.

class Employee { fire: = ..., otherMethod: = ...}
class Missile { fire: = ..., yetMoreMethod: = ...}
interface ICanFire { fire: = ...}
val e = new Employee
val m = new Missile
ICanFire bigGuy = if(util.Random.nextBoolean) e else m
bigGuy.fire

¿Qué pasa si dijimos:

interface IButtonEvent { fire: = ...}
interface IMouseButtonEvent { fire: = ...}
...

TypeScript permitirá esto, C # no lo hará.

Dado que TypeScript pretende trabajar bien con el DOM que usa la escritura "suelta", es la única opción sensata para escribir.

Dejo que el lector decida si les gusta la "tipificación estructural" ...