Extensibilidad

¡Hola!

Con el tema de interfaces se recomienda tener mucho en cuenta el principio I de los principios SOLID, es decir, Interface segregation o segregación de interfaces, este principio consiste en que una clase no debería de tener implementada una interfaz con más métodos de los que necesita, ejemplo, de una interfaz llamada IAnimales que tiene los siguientes métodos:

• Volar
• Comer
• Correr
• Caminar

Una clase llamada Perro no debería de poder implementar esta interfaz, porque un perro no puede volar (a menos que estés en una película de terror), aplicando el principio de segregación de interfaces, se recomienda dividir esta interfaz, ejemplo:

interface IAnimales {
  correr(): void;
  caminar(): void;
}

interface IAnimalesVoladores extends IAnimales {
  volar(): void;
}

interface IAnimalesNoVoladores extends IAnimales {
  noVolar(): void;
  saltar(): void;
}

class Pajaro implements IAnimalesVoladores {

  public correr(): void {}
  public caminar(): void {}
}

class Perro implements IAnimalesNoVoladores {
  public volar(): void {}
  public noVolar(): void {}
  public saltar(): void {}
  public correr(): void {}
  public caminar(): void {}
}

Espero que te sea de ayuda este aporte.

La extensibilidad es una medida de la capacidad de extender un sistema y el nivel de esfuerzo requerido para implementar la extensión.

💡 Documentación de todas las convenciones a las que se ha llegado.

Extensibilidad:

Capacidad de agregar nuevas cosas sin la necesidad de modificar en gran forma lo ya existente

Interfaz

Estipula las reglas que, las clases que lo implementen, tienen que seguir.
En este sentido, una interfaz puede entenderse como un contrato abstracto que establece el comportamiento esperado del componente que la implementa, así como las restricciones, requisitos y formatos de entrada y salida que deben cumplirse.

trabajar con interfaces, al principio es muy chocante, suelen ser conceptos muy abstractos

Extensibilidad:

• Cambios sencillos y comprensibles
• Cambios por contrato y/o interfaz
  requiere…
• Comprender el problema
• Consenso en la norma estándar

El chiste está en iterar, rápido, sencillo y con amplios márgenes de mejora

solo reorganize el codigo para que se vea desde lo mas independiente (arriba) hasta lo mas dependiente (abajo)

// HttpGateway file
import 'http' from 'HttpModule'

class HttpGateway:
  private url = '/api'
  public method fetchManu(resource) is
    // url will be /api/users
    return http.get(url + '/' + resource)

// file client
import 'httpGateway' from 'HttpGateway'
class UserService:
  public method getAll() is
    return httpGateway.fetchMany('users')

Esto me ha sucedido con bash script, tuve que implementar algo asi pero con llamadas para manipular al sistema operativo.

Pero lo hice sin tener esta teoría, solo fue intuición, tambien me hace recordar cosas que se hacen en redes.

Usar tantas herramientas dentro de un proyecto puede ser enredoso pero si no se aplican patrones, espero mucho de este curso para fortalecer las bases del diseño de patrones

En TS es muy común usar interfaces.

Las interfaces son muy usadas en el proyecto que estoy actualmente trabajando con CSharp, el concepto es claro para mi.

Excelente clase, todo super interesante y claro 👍

Creo que toda esta explicación de contratos y el ejemplo de RestGateway y GraphqlGateway son parte de lo que es el Principio de Inversión de Dependencias (5to principio SOLID) https://blog.logrocket.com/dependency-inversion-principle-typescript/

si con servicios WCF me gusta esa implementación pero se que actualmente se esta usando mas servicios REST.