static void

Enterprise Library Logging With No Configuration

While you can use Log4net with no configuration (it just doesn't log), you can't do it with Enterprise Library Logging. If you try to write to the logger, you get (in EntLib4) a ConfigurationErrorsException or (in EntLib5) an ActivationException.

This is some code which traps a missing configuration error and builds it manually. This is the EntLib 5 version; to use it with EntLib 4 it just uses the other error trap, and you new up a LogWriter instead of a LogWriterImpl. This is adapted from this code (EntLib 2!).

It's a singleton so just use it like LogLoader.Instance.LogWriter.Write("Error!") (see useage).


using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;
using Microsoft.Practices.EnterpriseLibrary.Logging;
using Microsoft.Practices.EnterpriseLibrary.Logging.Filters;
using Microsoft.Practices.EnterpriseLibrary.Logging.Formatters;
using Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners;
using Microsoft.Practices.ServiceLocation;
namespace EntLib5NoConfig
    /// <summary>
    /// Singleton that gets the logWriter
    /// </summary>
    sealed class LogLoader
        private const string GeneralCategory = "General";
        private const string ErrorCategory = "Errors";
        //Singleton pattern is Skeet #4 thread-safe without locks
        private static readonly LogLoader Loader = new LogLoader();
        static LogLoader()
            // Explicit static constructor to tell C# compiler
            // not to mark type as beforefieldinit
        /// <summary>
        /// Initializes a new instance of the <see cref="LogLoader"/> class.
        /// </summary>
                var factory = new LogWriterFactory(ConfigurationSourceFactory.Create());
                LogWriter = factory.Create();
            catch (ConfigurationErrorsException)
                // in EntLib4
            catch (ActivationException)
                // in EntLib5
        /// <summary>
        /// Access the singleton
        /// </summary>
        /// <value>The instance.</value>
        public static LogLoader Instance
            get { return Loader; }
        /// <summary>
        /// Gets the log writer.
        /// </summary>
        /// <value>The log writer.</value>
        public LogWriter LogWriter { get; private set; }
        /// <summary>
        /// Creates a manual writer.
        /// </summary>
        public void CreateManualWriter()
            var formatter = new TextFormatter(
                "Timestamp: {timestamp}{newline}" +
                "Category: {category}{newline}" +
                "Message: {message}{newline}" +
                "Extended Properties: {dictionary({key} - {value}{newline})}");
            // Log messages to event log
            var logListener = new FormattedEventLogTraceListener("Enterprise Library Logging", formatter);
            // var logListener = new FlatFileTraceListener("D:\\messages.log", string.Empty, string.Empty, formatter);
            //this source has our listener
            var mainLogSource = new LogSource(ErrorCategory, SourceLevels.All);
            // Don't log to this source
            var emptyLogSource = new LogSource("Empty");
            // "Error" category goes to main log source
            var traceSources = new Dictionary<string, LogSource> { { ErrorCategory, mainLogSource } };
            // filter "Error" category
            var categoryFilter = new CategoryFilter("Only Errors", new List<string> { ErrorCategory }, CategoryFilterMode.DenyAllExceptAllowed);
            var filters = new List<ILogFilter> { categoryFilter };
            // in EntLib5 can't use LogWriter (it's abstract) or LogWriterFactory (which uses IServiceLocator)
            LogWriter = new LogWriterImpl(
                //The collection of filters to use when processing an entry
                //The trace sources to dispatch entries to
                //The special LogSource to which all log entries should be logged.
                //The special LogSource to which log entries with at least one non-matching category should be logged
                //The special LogSource to which internal errors must be logged
                //The default category to set when entry categories list of a log entry is empty
                //The tracing status
                //true if warnings should be logged when a non-matching category is found


I'd typically write a simpler facade over EntLib's own static Logger facade (so I can Log.Info() or Log.Error() like in Log4net).

var entry = new LogEntry
                     Severity = TraceEventType.Error,
                     Message = message
 var frame = new StackFrame(1);
 var src = frame.GetMethod().ReflectedType + "." + frame.GetMethod().Name;
 entry.ExtendedProperties.Add("Stack", src);