Korzystanie StructureMap z log4net owijki

Question

Mam następujący interfejs:

public interface ILogger 
{ 
    void Debug(string message, params object[] values); 
    void Info(string message, params object[] values); 
    void Warn(string message, params object[] values); 
    void Error(string message, params object[] values); 
    void Fatal(string message, params object[] values); 
} 

i następujący realizacji:

public class Log4netLogger : ILogger 
{ 
    private ILog _log; 

    public Log4netLogger(Type type) 
    { 
     _log = LogManager.GetLogger(type); 
    } 

    public void Debug(string message, params object[] values) 
    { 
     _log.DebugFormat(message, values); 
    } 

    // other logging methods here... 

} 

Mój pomysł polegał na użyciu StructureMap instancję klasy Log4netLogger z użyciem rodzaju klasa, która zrobiła logowanie. Jednak nie mogę dla mojego życia dowiedzieć się, jak przekazać typ wywołującej klasy do structuremap, tak aby mogła zostać przekazana do konstruktora implementacji rejestrowania. Jakakolwiek rada, jak to zrobić (lub lepszy sposób) byłaby najbardziej doceniana.

Answer 1

Jeśli parametr typu jest specyficzny dla kontekstu, nie sądzę, że to zadziała, jak pokazano. Jeśli trzeba przekazać kontekst coś konkretnego w konstruktorze, jesteś prawdopodobnie będzie musiał utworzyć interfejs fabrycznego i realizację, która zwraca instancję ILogger:

public interface ILoggerFactory 
{ 
    ILogger Create(Type type); 
} 

public class LoggerFactory : ILoggerFactory 
{ 
    public ILogger Create(Type type) 
    { 
     return new Log4netLogger(type); 
    } 
} 

to może być możliwe, aby bootstrap StructureMap dostarczyć instancja, którą chcesz na podstawie typu, ale która zakłada ograniczoną liczbę typów, które znasz z góry.

Answer 2

Naprawdę muszę wyjść z przyzwyczajenia odpowiadania na moje własne pytanie, ale dla tych, którzy go przeżywają, oto odpowiedź.

return ObjectFactory.With(type).GetInstance<T>(); 

I rzeczywiście mają owijkę do StructureMap (aby uniknąć narażania zależność StructureMap do mojego app), który wygląda następująco:

public static class ServiceManager 
{ 
    public static T Get<T>() 
    { 
     return ObjectFactory.GetInstance<T>(); 
    } 

    public static T Get<T>(Type type) 
    { 
     return ObjectFactory.With(type).GetInstance<T>(); 
    } 
} 

każdym razem w kodzie muszę rejestrator wzywam następujące:

ServiceManager.Get<ILogger>(GetType()).Info("Logging page view..."); 

Answer 3

Używamy podobnego opakowania ILogger wokół log4net i zwykle używamy wtrysku konstruktora. Używamy przechwytywacza jako metody fabrycznej odpowiedzialnej za tworzenie rejestratora. Oto nasz typowy rejestr do konfiguracji rejestrowania.

public class CommonsRegistry : Registry 
{ 
    public CommonsRegistry() 
    { 
     For<ILogger>() 
      .AlwaysUnique() 
      .TheDefault.Is.ConstructedBy(s => 
      { 
       if (s.ParentType == null) 
        return new Log4NetLogger(s.BuildStack.Current.ConcreteType); 

       return new Log4NetLogger(s.ParentType); 
      }); 

     var applicationPath = Path.GetDirectoryName(Assembly.GetAssembly(GetType()).Location); 
     var configFile = new FileInfo(Path.Combine(applicationPath, "log4net.config")); 
     XmlConfigurator.ConfigureAndWatch(configFile); 
    } 
} 

Kontrola typu zerowego typu jest konieczna, gdy istnieją zależności od konkretnych typów.

Reszta to opcjonalne elementy konfiguracji protokołu log4net.

Jedną rzeczą, którą lubię w tej konfiguracji, jest możliwość korzystania z zerowych rejestratorów do testowania jednostkowego.