Inyección de dependencias y registradores con nombre

Estoy interesado en aprender más sobre cómo las personas inyectan el registro con plataformas de inyección de dependencias. Aunque los enlaces a continuación y mis ejemplos se refieren a log4net y Unity, no necesariamente voy a usar ninguno de ellos. Para dependency injection/IOC, probablemente usaré MEF ya que es el estándar en el que se está asentando el resto del proyecto (large).

Soy muy nuevo en dependency injection / ioc y soy bastante nuevo en C# y. NET (he escrito muy poco código de producción en C#/. NET después de los últimos 10 años de VC6 y VB6). He investigado mucho las diversas soluciones de registro que existen, así que creo que tengo un manejo decente de sus conjuntos de características. Simplemente no estoy lo suficientemente familiarizado con la mecánica real de obtener una dependencia inyectada (o, tal vez más "correctamente", obtener una versión abstracta de una dependencia inyectada).

He visto otras publicaciones relacionadas con el registro y / o la inyección de dependencias como: dependencia interfaces de inyección y registro

Mejores prácticas de registro

¿Cómo sería una clase Wrapper de Log4Net?

Otra vez acerca de log4net y Unity IOC config

Mi pregunta no tiene que ver específicamente con "¿Cómo inyectar la plataforma de registro xxx usando la herramienta ioc yyy?"Más bien, estoy interesado en cómo las personas han manejado el empaquetado de la plataforma de registro (como a menudo, pero no siempre se recomienda) y la configuración (es decir, la aplicación.config). Por ejemplo, usando log4net como ejemplo, podría configurar (en la aplicación.config) un número de loggers y luego obtener esos loggers (sin inyección de dependencias) en la forma estándar de usar código como este:

private static readonly ILog logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

Alternativamente, si mi registrador no se nombra para una clase, sino para un área funcional, podría hacer esto:

private static readonly ILog logger = LogManager.GetLogger("Login");
private static readonly ILog logger = LogManager.GetLogger("Query");
private static readonly ILog logger = LogManager.GetLogger("Report");

Entonces, supongo que mis "requisitos"serían algo como esto:

1. Me gustaría aislar la fuente de mi producto de un directo dependencia de una plataforma de registro.

2. Me gustaría poder resolver una instancia de logger con nombre específico (probablemente compartiendo la misma instancia entre todos los solicitantes de la misma instancia con nombre) ya sea directa o indirectamente por algún tipo de inyección de dependencia, probablemente MEF.

3. No se si llamaría a esto un requisito difícil, pero me gustaría la capacidad de obtener un logger con nombre (diferente al logger de clase) bajo demanda. Por ejemplo, podría crear un logger para mi clase basado en el nombre de la clase, pero un método necesita diagnósticos particularmente pesados que me gustaría controlar por separado. En otras palabras, es posible que desee que una sola clase "dependa" de dos instancias de registro separadas.

Comencemos con el número 1. He leído una serie de artículos, principalmente aquí en stackoverflow, sobre si es o no una buena idea envolver. Consulte el enlace" mejores prácticas " anterior y vaya al comentario de jeffrey hantin para ver una vista por qué es malo envolver log4net. Si usted envolviera (y si usted pudiera envolver con eficacia) ¿usted envolvería estrictamente para el propósito de la inyección/del retiro del depdency directo? O también trataría de abstraer parte o la totalidad de la aplicación log4net.información de configuración?

Digamos que quiero usar System.Diagnósticos, probablemente me gustaría implementar un registrador basado en la interfaz (tal vez incluso utilizando la interfaz "común" ILogger/ILog), probablemente basado en TraceSource, para que pudiera inyectarlo. Le implemente la interfaz, por ejemplo, a través de TraceSource, y simplemente use el Sistema.Aplicación de diagnóstico.¿información de configuración tal cual?

Algo como esto:

public class MyLogger : ILogger
{
  private TraceSource ts;
  public MyLogger(string name)
  {
    ts = new TraceSource(name);
  }

  public void ILogger.Log(string msg)
  {
    ts.TraceEvent(msg);
  }
}

Y úsalo así:

private static readonly ILogger logger = new MyLogger("stackoverflow");
logger.Info("Hello world!")

Pasando al número 2 ... ¿Cómo resolver una instancia de logger con nombre particular? Debería aprovechar la aplicación.información de configuración de la plataforma de registro que elija (es decir, resolver los registradores en función del esquema de nombres en la aplicación.config)? Por lo tanto, en el caso de log4net, ¿podría preferir " inyectar" LogManager (tenga en cuenta que sé que esto no es posible ya que es un objeto estático)? Podría empaquetar LogManager (llamarlo MyLogManager), darle una interfaz ILogManager, y luego resolver MyLogManager.Interfaz ILogManager. Mis otros objetos podrían tener una dependencia (Importación en lenguaje MEF) en ILogManager (Exportación desde el ensamblado donde se implementa). Ahora podría tener objetos como este:

public class MyClass
{
  private ILogger logger;
  public MyClass([Import(typeof(ILogManager))] logManager)
  {
    logger = logManager.GetLogger("MyClass");
  }
}

Cada vez que se llama a ILogManager, delegaría directamente al LogManager de log4net. Alternativamente, podría el LogManager envuelto tomar las instancias de ILogger que se basa en la aplicación.config y añadirlos a la (a ?) MEF contenedor por nombre. Más tarde, cuando se solicita un logger del mismo nombre, se consulta el LogManager envuelto para ese nombre. Si el ILogger está allí, se resuelve de esa manera. Si esto es posible con MEF, ¿hay algún beneficio hacerlo?

En este caso, realmente, solo ILogManager se "inyecta" y puede entregar instancias de ILogger de la manera en que log4net normalmente lo hace. ¿Cómo se compara este tipo de inyección (esencialmente de una fábrica) con la inyección de las instancias de logger nombradas? Esto permite un aprovechamiento más fácil de la aplicación log4net (u otra plataforma de registro).archivo de configuración.

Sé que puedo obtener instancias nombradas del contenedor MEF de esta manera:

var container = new CompositionContainer(<catalogs and other stuff>);
ILogger logger = container.GetExportedValue<ILogger>("ThisLogger");

Pero, ¿cómo puedo introducir las instancias nombradas en el contenedor? Conozco el modelo basado en atributos donde podría tener diferentes implementaciones de ILogger, cada una de que se nombra (a través de un atributo MEF), pero eso realmente no me ayuda. ¿Hay una manera de crear algo así como una aplicación.config (o una sección en él) que enumeraría los registradores (todos de la misma implementación) por nombre y que MEF podría leer? Podría/debería haber un "administrador" central (como MyLogManager) que resuelva los loggers nombrados a través de la aplicación subyacente.config y luego inserta el logger resuelto en el contenedor MEF? De esta manera estaría disponible para alguien más que tenga acceso a la mismo contenedor MEF (aunque sin el conocimiento de MyLogManager de cómo usar la aplicación de log4net.información de configuración, parece que el contenedor no sería capaz de resolver ningún registrador con nombre directamente).

Esto ya ha llegado bastante largo. Espero que sea coherente. Por favor, siéntase libre de compartir cualquier información específica sobre cómo su dependencia inyectó una plataforma de registro (lo más probable es que consideremos log4net, NLog o algo (con suerte delgado) construido en el Sistema.Diagnóstico) en su aplicación.

¿Inyectó el "manager" y lo hizo devolver instancias de logger?

¿Ha añadido alguna de su propia información de configuración en su propia sección de configuración o en la sección de configuración de su plataforma DI para que sea más fácil/posible inyectar instancias de logger directamente (es decir, hacer que sus dependencias estén en ILogger en lugar de ILogManager).

¿Qué hay de tener un contenedor estático o global que tenga la interfaz ILogManager en él o el conjunto de instancias ILogger con nombre en ella. Por lo tanto, en lugar de inyectar en el sentido convencional (a través de datos de constructor, propiedad o miembro), la dependencia de registro se resuelve explícitamente bajo demanda. Es esta una buena o mala manera de inyectar dependencia.

Estoy marcando esto como una wiki comunitaria ya que no parece una pregunta con una respuesta definitiva. Si alguien siente lo contrario, siéntase libre de cambiarlo.

Gracias por cualquier ayuda!