लॉग निंजा हल किए गए निर्भरता अनुप्रयोग स्टार्ट-अप

Question

हमने निनजा संस्करण 2 को हमारे आईओसी कंटेनर के रूप में कॉन्फ़्रेंस नामकरण के समाधान के साथ विस्तार के साथ विस्तार करना शुरू कर दिया है। हम लॉगिंग के लिए लॉग 4नेट का भी उपयोग कर रहे हैं।

मुझे जो चाहिए वह निनजेक्ट के लिए उन सभी निर्भरताओं को लॉग इन करना है जो उन्हें मिले हैं और उन्हें हल करने के लिए, विशेष रूप से एप्लिकेशन स्टार्ट-अप पर क्या हल होगा।

मुझे लॉगिंग एक्सटेंशन मिला है, लेकिन इसे पाने के लिए इसका उपयोग करने के तरीके पर दस्तावेज़ या उदाहरण नहीं मिल सकते हैं।

संपादित करें:

के बाद से इसे यहाँ अनुरोध किया गया था वर्ग, जो स्टार्टअप पर डिफ़ॉल्ट बाइंडिंग लॉग करता है, log4net

सार्वजनिक वर्ग DefaultBindingGeneratorWithLogging उपयोग कर रहा है: IBindingGenerator { निजी केवल पढ़ने के लिए 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

आप शायद 'सक्रियणस्ट्रेटी' का अपना उदाहरण बनाकर जो करने की कोशिश कर रहे हैं उसे प्राप्त कर सकते हैं।

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

आप तार इस जब आप अपने कर्नेल बनाने: यहाँ एक है कि मैं सक्रियण/छोड़ना नजर रखने के लिए उपयोग कर रहा था है।

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

     kernel.Load<AppModule>(); 

     return kernel; 
    } 

उम्मीद है कि इससे मदद मिलती है।

बॉब