प्रिज्म में लॉग इन करने का सबसे आसान तरीका संपत्ति बूटस्ट्रैपर में संपत्ति को ओवरराइड करना है। LoggerFacade को ओवरराइड करके, आप किसी भी कॉन्फ़िगरेशन के साथ किसी भी कॉन्फ़िगरेशन के साथ पास कर सकते हैं जब तक कि लॉगर ILoggerFacade इंटरफ़ेस लागू करता है।
मैंने पाया (मैं उद्यम पुस्तकालय लॉगिंग ब्लॉक का उपयोग कर रहा है, लेकिन log4net के लिए कुछ इसी तरह सीधे आगे होना चाहिए लागू करने) प्रवेश करने के लिए काफी अच्छी तरह से काम करने के लिए निम्नलिखित:
अपने शेल में एक Boostrapper बनाएँ:
-My Project
-Shell Module (add a reference to the Infrastructure project)
-Bootstrapper.cs
अपने इंफ्रास्ट्रक्चर परियोजना में एक लॉगिंग एडाप्टर बनाएँ, अर्थात्:
-My Project
-Infrastructure Module
-Adapters
-Logging
-MyCustomLoggerAdapter.cs
-MyCustomLoggerAdapterExtendedAdapter.cs
-IFormalLogger.cs
MyCustomLoggerAdapt er कक्षा बूटस्ट्रैपर में 'लॉगरफेकडे' प्रॉपर्टी को ओवरराइड करने के लिए उपयोग की जाएगी। इसमें एक डिफ़ॉल्ट contstructor होना चाहिए कि सब कुछ खबर।
नोट: बूटस्ट्रैपर में LoggerFacade प्रॉपर्टी को ओवरराइड करके, आप अपने स्वयं के आंतरिक संदेशों को लॉग इन करने के लिए प्रिज्म के लिए लॉगिंग मैकेनिसिम प्रदान कर रहे हैं।आप अपने लॉजर में अपने लॉजर का उपयोग कर सकते हैं, या आप लॉगर को अधिक पूर्ण रूप से फीचर्ड लॉगर के लिए बढ़ा सकते हैं। (देखें MyCustomLoggerAdapterExtendedAdapter/IFormalLogger)
public class MyCustomLoggerAdapter : ILoggerFacade
{
#region ILoggerFacade Members
/// <summary>
/// Logs an entry using the Enterprise Library logging.
/// For logging a Category.Exception type, it is preferred to use
/// the EnterpriseLibraryLoggerAdapter.Exception methods."
/// </summary>
public void Log(string message, Category category, Priority priority)
{
if(category == Category.Exception)
{
Exception(new Exception(message), ExceptionPolicies.Default);
return;
}
Logger.Write(message, category.ToString(), (int)priority);
}
#endregion
/// <summary>
/// Logs an entry using the Enterprise Library Logging.
/// </summary>
/// <param name="entry">the LogEntry object used to log the
/// entry with Enterprise Library.</param>
public void Log(LogEntry entry)
{
Logger.Write(entry);
}
// Other methods if needed, i.e., a default Exception logger.
public void Exception (Exception ex) { // do stuff }
}
MyCustomLoggerAdapterExtendedAdapterMyCustomLoggerAdapter से dervied जाता है और एक और अधिक पूर्ण लकड़हारा के लिए अतिरिक्त कंस्ट्रक्टर्स प्रदान कर सकते हैं।
public class MyCustomLoggerAdapterExtendedAdapter : MyCustomLoggerAdapter, IFormalLogger
{
private readonly ILoggingPolicySection _config;
private LogEntry _infoPolicy;
private LogEntry _debugPolicy;
private LogEntry _warnPolicy;
private LogEntry _errorPolicy;
private LogEntry InfoLog
{
get
{
if(_infoPolicy == null)
{
LogEntry log = GetLogEntryByPolicyName(LogPolicies.Info);
_infoPolicy = log;
}
return _infoPolicy;
}
}
// removed backing code for brevity
private LogEntry DebugLog... WarnLog... ErrorLog
// ILoggingPolicySection is passed via constructor injection in the bootstrapper
// and is used to configure various logging policies.
public MyCustomLoggerAdapterExtendedAdapter (ILoggingPolicySection loggingPolicySection)
{
_config = loggingPolicySection;
}
#region IFormalLogger Members
/// <summary>
/// Info: informational statements concerning program state,
/// representing program events or behavior tracking.
/// </summary>
/// <param name="message"></param>
public void Info(string message)
{
InfoLog.Message = message;
InfoLog.ExtendedProperties.Clear();
base.Log(InfoLog);
}
/// <summary>
/// Debug: fine-grained statements concerning program state,
/// typically used for debugging.
/// </summary>
/// <param name="message"></param>
public void Debug(string message)
{
DebugLog.Message = message;
DebugLog.ExtendedProperties.Clear();
base.Log(DebugLog);
}
/// <summary>
/// Warn: statements that describe potentially harmful
/// events or states in the program.
/// </summary>
/// <param name="message"></param>
public void Warn(string message)
{
WarnLog.Message = message;
WarnLog.ExtendedProperties.Clear();
base.Log(WarnLog);
}
/// <summary>
/// Error: statements that describe non-fatal errors in the application;
/// sometimes used for handled exceptions. For more defined Exception
/// logging, use the Exception method in this class.
/// </summary>
/// <param name="message"></param>
public void Error(string message)
{
ErrorLog.Message = message;
ErrorLog.ExtendedProperties.Clear();
base.Log(ErrorLog);
}
/// <summary>
/// Logs an Exception using the Default EntLib Exception policy
/// as defined in the Exceptions.config file.
/// </summary>
/// <param name="ex"></param>
public void Exception(Exception ex)
{
base.Exception(ex, ExceptionPolicies.Default);
}
#endregion
/// <summary>
/// Creates a LogEntry object based on the policy name as
/// defined in the logging config file.
/// </summary>
/// <param name="policyName">name of the policy to get.</param>
/// <returns>a new LogEntry object.</returns>
private LogEntry GetLogEntryByPolicyName(string policyName)
{
if(!_config.Policies.Contains(policyName))
{
throw new ArgumentException(string.Format(
"The policy '{0}' does not exist in the LoggingPoliciesCollection",
policyName));
}
ILoggingPolicyElement policy = _config.Policies[policyName];
var log = new LogEntry();
log.Categories.Add(policy.Category);
log.Title = policy.Title;
log.EventId = policy.EventId;
log.Severity = policy.Severity;
log.Priority = (int)policy.Priority;
log.ExtendedProperties.Clear();
return log;
}
}
public interface IFormalLogger
{
void Info(string message);
void Debug(string message);
void Warn(string message);
void Error(string message);
void Exception(Exception ex);
}
में Bootstrapper:
public class MyProjectBootstrapper : UnityBootstrapper
{
protected override void ConfigureContainer()
{
// ... arbitrary stuff
// create constructor injection for the MyCustomLoggerAdapterExtendedAdapter
var logPolicyConfigSection = ConfigurationManager.GetSection(LogPolicies.CorporateLoggingConfiguration);
var injectedLogPolicy = new InjectionConstructor(logPolicyConfigSection as LoggingPolicySection);
// register the MyCustomLoggerAdapterExtendedAdapter
Container.RegisterType<IFormalLogger, MyCustomLoggerAdapterExtendedAdapter>(
new ContainerControlledLifetimeManager(), injectedLogPolicy);
}
private readonly MyCustomLoggerAdapter _logger = new MyCustomLoggerAdapter();
protected override ILoggerFacade LoggerFacade
{
get
{
return _logger;
}
}
}
अंत में, या तो लकड़हारा उपयोग करने के लिए, तुम सब करने की जरूरत है उचित इंटरफ़ेस आपके क्लास 'निर्माता के लिए जोड़ रहा है और UnityContainer के लिए लकड़हारा इंजेक्षन जाएगा आप:
public partial class Shell : Window, IShellView
{
private readonly IFormalLogger _logger;
private readonly ILoggerFacade _loggerFacade;
public Shell(IFormalLogger logger, ILoggerFacade loggerFacade)
{
_logger = logger;
_loggerFacade = loggerFacade
_logger.Debug("Shell: Instantiating the .ctor.");
_loggerFacade.Log("My Message", Category.Debug, Priority.None);
InitializeComponent();
}
#region IShellView Members
public void ShowView()
{
_logger.Debug("Shell: Showing the Shell (ShowView).");
_loggerFacade.Log("Shell: Showing the Shell (ShowView).", Category.Debug, Priority.None);
this.Show();
}
#endregion
}
मुझे नहीं लगता कि आपको लॉगिंग नीति के लिए एक अलग मॉड्यूल की आवश्यकता है। लॉग इन पॉलिसी को अपने इंफ्रास्ट्रक्चर मॉड्यूल में जोड़कर, अन्य सभी मॉड्यूल आवश्यक संदर्भ प्राप्त करेंगे (माना जाता है कि आप अपने अन्य मॉड्यूल के संदर्भ के रूप में आधारभूत संरचना मॉड्यूल जोड़ते हैं)। और अपने बूस्ट्रैपर में लॉगर जोड़कर, आप यूनिटीकंटनर को आवश्यकतानुसार लॉगिंग नीति इंजेक्ट करने दे सकते हैं।
कोडप्लेक्स पर कंपोजिट WPF contrib प्रोजेक्ट पर simple example of uisng Log4Net भी है।
HTH के
मुझे इस समाधान में log4net की पदानुक्रमित लॉगिंग याद आ रही है। मुझे लगता है कि कुछ भी प्रिज्म में गायब है। –