usine AutoFac

Question

Je suis habitué à créer mes propres usines comme indiqué (ce qui est simplifié pour illustration):

public class ElementFactory 
{ 
    public IElement Create(IHtml dom) 
    { 
     switch (dom.ElementType) 
     { 
      case "table": 
       return new TableElement(dom); 
      case "div": 
       return new DivElement(dom); 
      case "span": 
       return new SpanElement(dom); 
     } 
     return new PassthroughElement(dom); 
    } 
} 

Je suis enfin décidé d'utiliser un conteneur IoC (AutoFac) dans mon courant projet, et je me demande s'il existe une façon magique de réaliser la même chose avec élégance avec AutoFac?

Answer 1

Réponse courte: Oui. Réponse plus longue: Tout d'abord, dans les cas simples où une classe Foo est enregistrée comme implémentation pour IFoo, les paramètres du constructeur ou les propriétés de type Func<IFoo> seront automatiquement résolus par Autofac, sans nécessiter de câblage supplémentaire. Autofac va injecter un délégué qui exécute essentiellement container.Resolve<IFoo>() lorsqu'il est appelé.

Dans les cas plus complexes comme le vôtre, où la concrétion exacte renvoyée est basée sur les paramètres d'entrée, vous pouvez faire l'une des deux choses suivantes. D'abord, vous pouvez enregistrer une méthode de fabrication comme valeur de retour pour fournir une résolution paramétrées:

builder.Register<IElement>((c, p) => { 
    var dom= p.Named<IHtml>("dom"); 
    switch (dom.ElementType) 
    { 
     case "table": 
      return new TableElement(dom); 
     case "div": 
      return new DivElement(dom); 
     case "span": 
      return new SpanElement(dom); 
    } 
    return new PassthroughElement(dom); 
    }); 

//usage 
container.Resolve<IElement>(new NamedParameter("dom", domInstance)) 

C'est le type-safe (domInstance ne sera pas vérifiée par le compilateur pour vous assurer qu'il est un iHTML), ni très nettoyer. Au lieu de cela, une autre solution consiste à enregistrer en fait la méthode d'usine comme Func:

builder.Register<Func<IHtml, IElement>>(dom => 
{ 
    switch (dom.ElementType) 
    { 
     case "table": 
      return new TableElement(dom); 
     case "div": 
      return new DivElement(dom); 
     case "span": 
      return new SpanElement(dom); 
    } 
    return new PassthroughElement(dom); 
}); 


public class NeedsAnElementFactory //also registered in AutoFac 
{ 
    protected Func<IHtml,IElement> CreateElement {get; private set;} 

    //AutoFac will constructor-inject the Func you registered 
    //whenever this class is resolved. 
    public NeedsAnElementFactory(Func<IHtml,IElement> elementFactory) 
    { 
     CreateElement = elementFactory; 
    } 

    public void MethodUsingElementFactory() 
    { 
     IHtml domInstance = GetTheDOM(); 

     var element = CreateElement(domInstance); 

     //the next line won't compile; 
     //the factory method is strongly typed to IHtml 
     var element2 = CreateElement("foo"); 
    } 
} 

Si vous voulez garder le code ElementFactory au lieu de le mettre dans le module Autofac, vous pouvez faire de la fabrique statique et inscrivez-vous dès que (Cela fonctionne particulièrement bien dans votre cas car votre méthode d'usine est trivialement statique):

public class ElementFactory 
{ 
    public static IElement Create(IHtml dom) 
    { 
     switch (dom.ElementType) 
     { 
      case "table": 
       return new TableElement(dom); 
      case "div": 
       return new DivElement(dom); 
      case "span": 
       return new SpanElement(dom); 
     } 
     return new PassthroughElement(dom); 
    } 
} 

... 

builder.Register<Func<IHtml, IElement>>(ElementFactory.Create);