Log start-up risolto con le dipendenze risolte

Question

Abbiamo iniziato a utilizzare la versione 2 di Ninject come contenitore IoC insieme all'estensione per la risoluzione mediante denominazione delle convenzioni. Stiamo anche utilizzando log4net per la nostra registrazione.

Quello che vorrei è che Ninject registri tutte le dipendenze che ha trovato e su cosa le risolverà, preferibilmente all'avvio dell'applicazione.

Ho trovato l'estensione di registrazione, ma non riesco a trovare documentazione o esempi su come usarlo per ottenere questo.

Edit:

Da quando è stato richiesto qui è la classe che registra le associazioni di default all'avvio, utilizzando log4net

public class DefaultBindingGeneratorWithLogging: IBindingGenerator { sola lettura privata kernel 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

Probabilmente è possibile ottenere ciò che si sta tentando di fare creando la propria istanza di "ActivationStrategy". Ecco uno che stavo usando per monitorare l'attivazione/disattivazione:

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); 
    } 
} 

Si collega questo quando si crea il kernel.

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

     kernel.Load<AppModule>(); 

     return kernel; 
    } 

Spero che questo aiuti.

Bob