Servicestack mit Funq - Autowiring per Konvention

Question

Ich habe einen Dienst, der eine IMyDependency in seinem Konstruktor nimmt. IMyDependency, MyDependency und der Dienst befinden sich alle in derselben Assembly. MyDependency hat einen einzelnen, öffentlichen, parameterlosen Konstruktor.

Zu meiner Überraschung, das hat nicht funktioniert:

container.RegisterAutoWired<IMyDependency>(); 

Es wirft einen "System.NullReferenceException".

Es funktioniert, wenn ich dies tun:

container.RegisterAutoWiredAs<MyDependency, IMyDependency>(); 

Aber dann, so tut dies:

container.RegisterAs<MyDependency, IMyDependency>(); 

Also, was ist der Unterschied? Wenn 'automatische Verdrahtung' keine konkrete Implementierung finden kann und es keinen Unterschied macht, ob Dienste, die die Abhängigkeit erfordern, gelöst werden können, was ist dann eine automatische Verdrahtung?

Soll Funq Ihre konkreten Implementierungen per Konvention finden können? Wenn ja, was ist diese Konvention, wenn nicht gleich genannt?

Danke.

Answer 1

Für einfache Abfragen wie diese ist es am besten, nur die Quelle, z. hier ist der Quellcode für RegisterAutoWired:

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

Es hat eine Auto-Kabel Fabrik über einekonkrete Umsetzung erzeugt. Eine Schnittstelle hat keine Implementierung, sie muss eine konkrete Klasse sein.

und der Quellcode für RegisterAs:

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

die nur eine kürzere alias ist man statt RegisterAutoWiredAs verwenden können.

Answer 2

Meinst du "Wie kann ich eine Lösung implementieren, um Baugruppen zu durchsuchen und automatisch Klassen in ServiceStack IOC basierend auf einer Konvention zu registrieren?"

Wenn ja, könnte ich eine Lösung für Sie:

1. Erstellen Sie eine Schnittstelle, die Ihre Inject-able Klassen implementieren wird.
2. Lassen Sie Ihre injizierbaren Klassen diese Schnittstelle implementieren.
3. Verwenden Sie im Boot-Strapping-Code reflection, um Ihre Assemblys zu durchsuchen und eine Liste aller Klassen zu erhalten, die die inject-fähige Schnittstelle implementieren.
4. Verwenden Sie Reflektion, um den Klassennamen und die Schnittstelle basierend auf Ihren Konventionen zu erhalten.
5. Rufen Sie die ServiceStack IOC-Methode RegisterAutoWiredType und übergeben Sie die Klasse und die Schnittstelle, um sie zu registrieren.

Zum Beispiel, wenn unsere Namenskonvention ist Class 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(); 
    } 
}