servicestack con funq - autowiring per convenzione

Question

Ho un servizio che prende un'IMyDependency nel suo costruttore. IMyDependency, MyDependency e il servizio vivono tutti nello stesso assembly. MyDependency ha un costruttore singolo, pubblico, senza parametri.

Con mia grande sorpresa, questo non ha funzionato:

container.RegisterAutoWired<IMyDependency>(); 

getta un "System.NullReferenceException".

Funziona se faccio questo:

container.RegisterAutoWiredAs<MyDependency, IMyDependency>(); 

Ma poi, così fa questo:

container.RegisterAs<MyDependency, IMyDependency>(); 

Allora, qual è la differenza? Se il "cablaggio automatico" non riesce a trovare un'implementazione concreta e non fa alcuna differenza se i servizi che richiedono la dipendenza possono essere risolti, qual è il cablaggio automatico?

Funq dovrebbe essere in grado di trovare le implementazioni concrete per convenzione? In tal caso, qual è questa convenzione, se non lo stesso nome?

Grazie.

Answer 1

Per query semplici come questa è meglio contattare la fonte, ad es. qui è il codice sorgente per RegisterAutoWired:

public IRegistration<T> RegisterAutoWired<T>() 
{ 
    var serviceFactory = GenerateAutoWireFn<T>(); 
    return this.Register(serviceFactory); 
} 

Esso genera una fabbrica di auto-wired nel corso di un Concrete implementazione. Un'interfaccia non ha implementazione, deve essere una classe concreta.

E il codice sorgente per RegisterAs:

public IRegistration<TAs> RegisterAs<T, TAs>() where T : TAs 
{ 
    return this.RegisterAutoWiredAs<T, TAs>(); 
} 

che è solo un alias più brevi è possibile utilizzare al posto di RegisterAutoWiredAs.

Answer 2

Intendi "come posso implementare una soluzione per cercare tra gli assembly e registrare automaticamente le classi in IOC di ServiceStack in base a una convenzione?"

Se è così, potrei avere una soluzione per voi:

1. creare un'interfaccia che le vostre classi Iniettare-grado attueranno.
2. Le classi iniettabili possono implementare tale interfaccia.
3. Nel codice di avvio utilizza la riflessione per cercare gli assiemi e ottenere un elenco di tutte le classi che implementano l'interfaccia iniettabile.
4. Utilizzare la riflessione per ottenere il nome classe e l'interfaccia in base alle convenzioni.
5. Chiamare il metodo IOC ServiceStack RegisterAutoWiredType e passare la classe e l'interfaccia per registrarli.

Per esempio se la nostra convenzione di denominazione è NomeClasse IClassName:

private static void RegisterCustomTypes(Container container) 
{ 
    //Get the Assembly Where the injectable classes are located. 
    var assembly = Assembly.GetAssembly(typeof(IInjectable)); 

    //Get the injectable classes 
    var types =assembly.GetTypes() 
    .Where(m => m.IsClass && m.GetInterface("IInjectable") != null); 

    //loop through the injectable classes 
    foreach (var theType in types) 
    { 
    //set up the naming convention 
    var className = theType.Name; 
    var interfaceName = string.Concat("I", className); 
    //create the interface based on the naming convention 
    var theInterface = theType.GetInterface(interfaceName); 
    //register the type with the convention 
    container.RegisterAutoWiredType(theType, theInterface); 
    } 
} 

public interface IInjectable 
{ 

} 

//This class can be injected 
public interface ITestManager : IInjectable 
{ 
    void Execute(int id); 
} 

public class TestManager : ITestManager 
{ 
    public void Execute(int id) 
    { 
     throw new System.NotImplementedException(); 
    } 
}