none
Problema con la arquitectura de una aplicación (referencias cíclicas) RRS feed

  • Question

  • Hola, tengo un problema con la arquitectura de capas. Necesito que dos capas se comuniquen de forma recíproca la una con la otra y no sé cómo hacerlo para no hacer referéncias cíclicas.
    Espero que me podais ayudar, gracias.
    Tuesday, October 17, 2006 4:52 PM

All replies

  • Hello, I have a problem with the architecture of layers. I need that two layers communicate of reciprocal form the one with the other and I do not know how to make it not to make referéncias cyclical. I hope that podais to help me, thanks.
    Tuesday, October 17, 2006 7:12 PM
  • Shiveta,

    Una manera de aproximar este problema, si no puede ser evitado, es definir un conjunto externo de interfaces que definan las responsabilidades y funciones de cada capa en forma externa a la misma (normalmente en un assembly independiente), de forma tal que introducirlas como un tercer elemento rompan la referencia cíclica.

    De esta forma, cada una de las dos capas implementará las interfaces que le corresponden, a la vez que usará las interfaces opuestas para interactuar con la otra capa. Para terminar de romper la dependencia cíclica, tienes que introducir un mecanismo que le permita obtener a cada capa una referencia a la implementación de las interfaces comunes en la capa opuesta de forma completamente independiente. Una excelente manera de hacerlo es introduciendo un patrón de "inyección de dependencias" o "inversión de control" que haga uso de factorías para hacer esta operación. Martin Fowler tiene buena información en su sitio acerca de estos patrones (desafortunadamente no hay traducción al español actualmente).

    Afortunadamente hay varias librerías que ayudan a implementarlos, incluyendo spring.net, structuremap y otros. Personalmente, me gusta el contenedor Windsor.

    --------------------------------------------------------------------------------------------------

    One way of approaching this problem, if it cannot be avoided, is to define an external set of interfaces that define the responsabilities of each layer (usually in an independent assembly), in such a way that they can be introduced as a third element and break the cyclic reference.

    In this way, each of the two layers will implement the corresponding interfaces, while at the same time using the opposing interfaces to interact with the other layer. To reall break up the cyclic dependency, you need to introduce a mechanism that allows each layer to get a reference to the other layer's implementation of the common interfaces without directly instantiating the implementation classes. An excellent way of accomplishing this is through the use of Dependency Injection or Inversion of Control patterns that make use of factories to do this. Martin Fowler has good information on his site about this patterns.

    Fortunately, there are several libraries available that help implementing them, like spring.net, structuremap and others. Personally, I like using the Windsor container in the Castle Project.
    Tuesday, October 17, 2006 8:00 PM
  • ObjectBuilder from the patterns group also provide an dependency injection framework. The one used by the CAB and EntLib.
    Tuesday, October 17, 2006 8:19 PM