Cualquier lugar donde necesite un valor de tiempo de ejecución para construir una dependencia particular, Abstract Factory es la solución.IoC Factory: Pros y contras para la interfaz frente a los delegados
Mi pregunta es: ¿Por qué muchas fuentes prefieren FactoryInterface sobre FactoryDelegate para implementar este patrón? ¿Cuáles son los pros y contras para ambas soluciones?
Aquí es un ejemplo para entender lo que quiero decir
Si usted tiene un servicio que necesita un repositorio con un cierto contexto a continuación, el constructor Servicio necesita una fábrica para crear o acceder a su repositorio.
La solución común para esto es crear un RepositoryFactoryInterface de esta manera.
public IRepositoryFactory {
IRepository Create(ContextInformation context);
}
public class MyService {
private IRepositoryFactory repositoryFactory;
public MyService(IRepositoryFactory repositoryFactory)
{
this.repositoryFactory = repositoryFactory:
}
public void DoSomeService()
{
ContextInformation context = ....;
IRepository repository = this.repositoryFactory.Create(context);
repository.Load(...);
...
repository.Save(...);
}
}
también es necesario para implementar la interfaz IRepositoryFactory alguna manera
public MyEf4RepositoryFactory : IRepositoryFactory
{
IRepository Create(ContextInformation context)
{
return new MyEf4Repository(context);
}
}
... y utilizarlo en la aplicación
public void main()
{
IRepositoryFactory repoFactory = new MyEf4RepositoryFactory();
IService service = new MyService(repoFactory);
service.DoSomeService();
}
End ----- solución de la corriente principal - ----
En lugar de RepositoryFactoryInterface puede hacer lo mismo con factorydelegate que requiere menos codificación como esta.
public class MyService {
private Func<ContextInformation, IRepository> repositoryFactory;
public MyService(Func<ContextInformation, IRepository> repositoryFactory)
{
this.repositoryFactory = repositoryFactory:
}
public void DoSomeService()
{
ContextInformation context = ....;
IRepository repository = this.repositoryFactory(context);
repository.Load(...);
...
repository.Save(...);
}
}
... y utilizarlo en la aplicación
public void main()
{
IService service = new MyService(context => new MyEf4Repository(context));
service.DoSomeService();
}
En mi opinión, el factorydelegate context => new MyEf4Repository(context) es mucho más compacto que declarar e implementar una interfaz IRepositoryFactory y MyEf4RepositoryFactory.
Debe haber una razón para esto y quiero saber por qué.
Aquí es una fuente de ejemplo que utiliza la interfaz de aproach: answer to is-there-a-pattern-for-initializing-objects-created-via-a-di-container
[Actualización] 15 meses después de hacer esta pregunta y tener más experiencia con los universers java he cambiado de opinión: Ahora prefiero las interfaces más delegados. Pero no puedo decir por qué. Es solo un sentimiento. Tal vez porque estoy más acostumbrado a eso?
El enfoque FactoryDelegate es la forma funcional de hacer las cosas. – George