Log ninject resolved dependencies application start-up

Question

Rozpoczęliśmy używanie programu Ninject w wersji 2 jako naszego kontenera IoC wraz z rozszerzeniem do rozpoznawania konwencji nazewnictwa. Używamy również log4net do naszego logowania.

Chciałbym, aby Ninject logował wszystkie znalezione zależności i do czego je doprowadzi, najlepiej przy uruchomieniu aplikacji.

Znalazłem rozszerzenie logowania, ale nie mogę znaleźć dokumentacji ani przykładów, jak go użyć, aby to uzyskać.

Edit:

Ponieważ poproszono tutaj jest klasa, która rejestruje domyślne powiązania na starcie, przy użyciu log4net

public class DefaultBindingGeneratorWithLogging: IBindingGenerator {private readonly jądra IKernel;

/// <summary> 
    /// Initializes a new instance of the <see cref="DefaultBindingGeneratorWithLogging"/> class. 
    /// </summary> 
    /// <param name="kernel">The kernel.</param> 
    public DefaultBindingGeneratorWithLogging(IKernel kernel) 
    { 
     this.kernel = kernel; 
    } 

    /// <summary> 
    /// Creates the bindings for a type. 
    /// </summary> 
    /// <param name="type">The type for which the bindings are created.</param> 
    /// <param name="bindingRoot">The binding root that is used to create the bindings.</param> 
    /// <returns> 
    /// The syntaxes for the created bindings to configure more options. 
    /// </returns> 
    public IEnumerable<IBindingWhenInNamedWithOrOnSyntax<object>> CreateBindings(Type type, IBindingRoot bindingRoot) 
    { 
     if (type.IsInterface || type.IsAbstract) 
     { 
      yield break; 
     } 

     Type interfaceForType = type.GetInterface("I" + type.Name, false); 
     if (interfaceForType == null) 
     { 
      yield break; 
     } 

     var log = kernel.Get<ILog>(); 
     if (!(kernel.GetBindings(interfaceForType).Any())) 
     { 
      bindingRoot.Bind(interfaceForType).To(type).InTransientScope(); 
      if (log.IsInfoEnabled && !String.IsNullOrWhiteSpace(interfaceForType.FullName)) 
      { 
       log.InfoFormat("Mapping {0} -> {1}", type.FullName, interfaceForType.FullName); 
      } 
     } 
     else 
     {     
      log.InfoFormat("Didn't map {0} -> {1} mapping already exists", type.FullName, interfaceForType.FullName); 
     } 
    } 
} 

Answer 1

Prawdopodobnie możesz osiągnąć to, co próbujesz zrobić, tworząc własne wystąpienie "ActivationStrategy". Oto jedna z tych, których używałem do monitorowania aktywacji/dezaktywacji:

public class MyMonitorActivationStrategy : ActivationStrategy 
{ 
    private ILogger _logger; 

    public override void Activate(Ninject.Activation.IContext context, Ninject.Activation.InstanceReference reference) 
    { 
     if(reference.Instance is ILogger) 
     { 
      _logger = (ILogger)reference.Instance; 
     } 
     _logger.Debug("Ninject Activate: " + reference.Instance.GetType()); 
     base.Activate(context, reference); 
    } 

    public override void Deactivate(Ninject.Activation.IContext context, Ninject.Activation.InstanceReference reference) 
    { 
     _logger.Debug("Ninject DeActivate: " + reference.Instance.GetType()); 
     base.Deactivate(context, reference); 
    } 
} 

Podłączasz to podczas tworzenia jądra.

protected override IKernel CreateKernel() 
    { 
    var kernel = new StandardKernel(); 
     kernel.Components.Add<IActivationStrategy, MyMonitorActivationStrategy>(); 

     kernel.Load<AppModule>(); 

     return kernel; 
    } 

Mam nadzieję, że to pomoże.

Bob