Service Locator più facile da usare dell'iniezione di dipendenza?

Question

L'applicazione sto lavorando si basa su Autofac come DI contenitore e uno dei motivi che mi ha fatto decidere di usarlo, tra gli altri, è stata la caratteristica delegato di fabbrica (vedi here)

Questo funziona bene per tutti i casi dove ho bisogno di ricreare gli stessi elementi più volte, come nel caso di alcuni report e schermate correlate. Alcuni report (anche quelli dello stesso tipo) vengono eseguiti contemporaneamente ma cambiano solo in base ai parametri definiti dall'utente, quindi ha senso (credo) inserire le factory per creare istanze, passare i parametri liberi e lasciare il resto al applicazione.

Il problema deriva dal fatto che ogni rapporto è composto da un numero variabile di sottoreti (attività) e ogni attività implementa un'interfaccia ITask. Ogni report può avere fino a 50 diverse attività da utilizzare e ogni attività incapsula un'operazione di business precisa. Una delle opzioni che ho è di iniettare le fabbriche delegate e crearle quando necessario.

Questi compiti devono essere dinamicamente generati dalle fabbriche e qualcosa come:

var myTaskA = _taskFactoryConcreteTaskA(); 
var myTaskB = _taskFactoryConcreteTaskB(); 
var myTaskC = _taskFactoryConcreteTaskC(); 
... 
var myTaskZZ = = _taskFactoryConcreteTaskZZ(); 

richiede un sacco di cablaggio manuale (delegati, il costruttore, il backup campi ecc), mentre qualcosa come

var myTaskA = _taskFactory.Create<ConcreteTaskA>(); 
var myTaskB = _taskFactory.Create<ConcreteTaskB>(); 
var myTaskC = _taskFactory.Create<ConcreteTaskC>(); 
... 
var myTaskZZ = _taskFactory.Create<ConcreteTaskZZ>(); 

sarebbe essere incredibilmente meno lavoro, specialmente se la _taskFactory esegue il wrapping del contenitore come mostrato in this other post, ma fondamentalmente significa che sto usando un localizzatore di servizi per creare i miei compiti.

Quali altre opzioni sono disponibili per risolvere questo problema?

(NOTA: c'è una buona probabilità Sono completamente fuori pista e che devo leggere molto di più su DI, nel qual caso qualsiasi contributo sarebbe ancora più importante)

Answer 1

Un approccio vale la pena indagare è quello di rompere le into'units problema del lavoro' che utilizzano un insieme di attività correlate:

public class WorkItem1 : ISomeWork 
{ 
    public WorkItem1(Task1 t1, Task2 t2...) { } 
    public void DoSomething() { ... } 
} 

Quindi, l'utilizzo di fabbriche sarebbe venuto giù verso someWorkFactory().DoSomething(), forse per un paio di diversi tipi di 'qualcosa'.

Una classe con un gran numero di dipendenze, su fabbriche o qualsiasi altra cosa, di solito indica che ci sono classi più piccole e più focalizzate che aspettano di essere scoperte per interrompere il lavoro.

Spero che questo aiuti.

Answer 2

Poiché gli stabilimenti indicati nella domanda non accettano argomenti, utilizza un odore di fabbrica di Leaky Abstraction. Come sottolinea Nicholas Blumhardt nella sua risposta, un approccio migliore potrebbe essere semplicemente iniettare ogni attività nel consumatore.

In questo caso, dal momento che tutte le attività implementano la stessa interfaccia, invece di iniettare fino a 50 diverse ITask casi, è possibile comporli:

public class MyConsumer 
{ 
    private readonly IEnumerable<ITask> tasks; 

    public MyConsumer(IEnumerable<ITask> tasks) 
    { 
     this.tasks = tasks; 
    } 

    public void DoSomething() 
    { 
     foreach (var t in this.tasks) 
     { 
      // Do something with each t 
     } 
    } 
} 

In alternativa, è possibile comporre la sequenza di ITasks in un Composite, che è in realtà la mia soluzione preferita:

public CompositeTask : ITask 
{ 
    private readonly IEnumerable<ITask> tasks; 

    public CompositeTask(IEnumerable<ITask> tasks) 
    { 
     this.tasks = tasks; 
    } 

    // Implement ITask by iterating over this.tasks 
} 

Ciò semplificherebbe il consumatore e ruotare il fatto che ci sono più di un compito da eseguire in un dettaglio implementativo :

public class MyConsumer 
{ 
    private readonly ITask task; 

    public MyConsumer(ITask task) 
    { 
     this.task = task; 
    } 

    public void DoSomething() 
    { 
     // Do something with this.task 
    } 
}