Wie zu vermeiden, Service-Locator Anti-Pattern?

Stimme ich mit @chrisichris und @Mark Seemann.

Graben der kernel aus dem controller. Ich würde wechseln, resolver Zusammensetzung ein wenig, so dass Ihr controller kann entfernen Sie die Abhängigkeit von den IoC-container und erlauben der resolver die einzige Sache, die sorgen über den IoC-container.

Dann, ich würde das lassen-resolver übergeben bekommen in den Konstruktor des Controllers. Dies ermöglicht es dem controller weit mehr getestet werden.

Beispiel:

public interface IMyServiceResolver
{
    List<IMyServiceInterface> Resolve(Type[] types);
}

public class NinjectMyServiceResolver : IMyServiceResolver
{
    private IKernal container = null;

    public NinjectMyServiceResolver(IKernal container)
    {
        this.container = container;
    }

    public List<IMyServiceInterface> Resolve(Type[] types)
    {
        List<IMyServiceInterface> services = new List<IMyServiceInterface>();

        foreach(var type in types)
        {
            IMyServiceInterface instance = container.Get(type);
            services.Add(instance);
        }

        return services;
    }
}

public abstract class MyController : Controller
{
    private IMyServiceResolver resolver = null;

    public MyController(IMyServiceResolver resolver) 
    { 
        this.resolver = resolver;
    }

    protected void DoActions(Type[] types)
    {
        var services = resolver.Resolve(types);

        foreach(var service in services)
        {
            service.DoAction();
        }
    }
}

Jetzt deinen controller nicht gekoppelt an einen bestimmten IoC container. Auch Ihre Steuerung ist viel mehr getestet werden, da Sie verspotten den Resolver und nicht verlangen, einen IoC-container für Ihre tests.

Alternativ, wenn Sie nicht bekommen, um zu Steuern, Wann ein controller instanziiert wird, kann man Sie leicht modifizieren:

public abstract class MyController : Controller
{
    private static IMyServiceResolver resolver = null;

    public static InitializeResolver(IMyServiceResolver resolver)
    {
        MyController.resolver = resolver;
    }

    public MyController() 
    { 
        //Now we support a default constructor
        //since maybe someone else is instantiating this type
        //that we don't control.
    }

    protected void DoActions(Type[] types)
    {
        var services = resolver.Resolve(types);

        foreach(var service in services)
        {
            service.DoAction();
        }
    }
}

Würden Sie dann rufen Sie diese an Ihrem einen Neustart der Anwendung zur Initialisierung der resolver:

MyController.InitializeResolver(new NinjectMyServiceResolver(kernal));

Wir Taten dies, um Griff-Elemente in XAML erstellt, die Abhängigkeiten aufgelöst, aber wir wollten zu entfernen Service Locator gerne Anfragen.

Bitte entschuldigt eventuelle syntaktische Fehler 🙂

Schreibe ich einen blog-post-Serie zum Thema refactoring einer MVVM-Anwendung mit dem Service Locator-Aufrufe in der Sicht Modelle, die Sie interessant finden könnte. Teil 2 kommt bald 🙂

http://kellabyte.com/2011/07/24/refactoring-to-improve-maintainability-and-blendability-using-ioc-part-1-view-models/

Ich hätte gerne ein bisschen mehr Informationen, bevor dieses posting Antworten, aber Kelly hat mich auf der Stelle. 🙂 Sagt mir mein code, wo mein Mund ist, so zu sprechen.

Wie ich schon sagte in meinem Kommentar zu Kelly, ich bin nicht einverstanden mit der Verschiebung des resolver/locator von einer statischen Implementierung einer injizierten Umsetzung. Ich Stimme mit ChrisChris, dass die Abhängigkeiten der abgeleiteten Typs muss geklärt werden sollten, die Klasse und nicht delegiert, um die base-Klasse.

Gesagt, hier ist, wie würde ich entfernen, das service location...

Erstellen-Befehl-Schnittstelle

Zuallererst würde ich erstellen Sie eine Kommando-Schnittstelle für die konkrete Implementierung. In diesem Fall sind die Typen gesendet, mit der DoActions Methode erzeugt aus Parametern, so würde ich erstellen Sie eine IAttributeCommand. Ich bin das hinzufügen einer Matches Methode, um den Befehl, um zu erklären den Befehl für die Nutzung durch bestimmte Arten.

public interface IAttributeCommand
{
    bool Matches(Type type);
    void Execute();
}

Befehl Hinzufügen Implementierungen

Die Schnittstelle implementieren, ich pass auf die spezifischen Abhängigkeiten, die ich ausführen müssen mein Kommando (gelöst zu werden, durch meine container). Ich hinzufügen, ein Prädikat zu, meine Methode Entspricht, und definieren Sie mein Verhalten Führen.

public class MyTypeAttributeCommand : IAttributeCommand
{
    MyDependency dependency;
            SomeOtherDependency otherDependency;

    public MyTypeAttributeCommand (MyDependency dependency, ISomeOtherDependency otherDependency)
    {
        this.dependency = dependency;
                    this.otherDependency = otherDependency
    }

    public bool Matches(Type type)
    {
        return type==typeof(MyType)
    }
    public void Execute()
    {
        //do action using dependency/dependencies
    }
}

Register Befehle mit Container

In StructureMap (verwenden Sie Ihre Lieblings-container), ich würde registrieren Sie das array wie folgt:

Scan(s=>
       {
                s.AssembliesFromApplicationBaseDirectory();
                s.AddAllTypesOf<IAttributeCommand>();
                s.WithDefaultConventions();
       } 

Auswählen und Ausführen von Befehlen, die auf der Basis des Typs

Schließlich, auf der Basis Klasse, ich definiere eine IAttributeCommand array in meine Argumente im Konstruktor injiziert werden, die von der IOC-container. Wenn der abgeleitete Typ geht in die types array, werde ich ausführen, den entsprechenden Befehl basierend auf dem Prädikat.

public abstract class MyController : Controller
{
    protected IAttributeCommand[] commands;

    public MyController(IAttributeCommand[] commands) { this.commands = commands); }

    protected void DoActions(Type[] types)
    {
        foreach(var type in types)
        {
            var command = commands.FirstOrDefault(x=>x.Matches(type));
            if (command==null) continue;

            command.Execute();
        }
    }
}

Wenn Sie mehrere Befehle verarbeiten kann, ein Typ, Sie können ändern Sie die Implementierung: commands.Where(x=>x.Matches(type)).ToList().ForEach(Execute);

Der Effekt ist der gleiche, aber es ist ein subtiler Unterschied, wie die Klasse aufgebaut ist. Die Klasse hat keine Kopplung an einen IOC-container, und es gibt keine service-Standort. Die Umsetzung wird mehr getestet als der Klasse konstruiert werden können, die mit seiner realen Abhängigkeiten, keine Notwendigkeit, Draht, eine container - /resolver.