VS - Microsoft.Practices.EnterpriseLibrary.Logging

string fileName = AppDomain.CurrentDomain.BaseDirectory + "\\log.txt";
File.AppendAllText(fileName, "start\r\n", Encoding.UTF8);

version 6.0.0.0 need set ExceptionManager
PM>  Install-Package EnterpriseLibrary.Logging
PM>  Install-Package EnterpriseLibrary.Common
PM>  Install-Package EnterpriseLibrary.ExceptionHandling
PM>  Install-Package EnterpriseLibrary.ExceptionHandling.Logging

Microsoft.Practices.EnterpriseLibrary.ConfigConsoleV6.vsix。这个工具的下载地址：http://www.microsoft.com/en-us/download/details.aspx?id=38789

<section name="loggingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.LoggingSettings, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />
 <section name="exceptionHandling" type="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Configuration.ExceptionHandlingSettings, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />

using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling;
using Microsoft.Practices.EnterpriseLibrary.Logging;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

        static AppLogger()
        {
            Logger.SetLogWriter(new LogWriterFactory().Create());
            IConfigurationSource config = ConfigurationSourceFactory.Create();
            ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);

            ExceptionManager exManager = factory.CreateManager();
            ExceptionPolicy.SetExceptionManager(factory.CreateManager());
        }

        public static void LogError(Exception ex)
        {
            lock (staticLock)
            {

                ExceptionPolicy.HandleException(ex, AppConfiguration.ExceptionPolicyName);
            }
        }

App.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="loggingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.LoggingSettings, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />
    <section name="exceptionHandling" type="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Configuration.ExceptionHandlingSettings, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration" />
      <sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
      <section name="Common.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
    </sectionGroup>
  </configSections>
    <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <container>
        <register type="Common.Interfaces.IGetServiceResponseBLL,R365.Common" mapTo="Common.BusinessLogic.CallTestBLL,Common" />
      </container>
  </unity>
  <applicationSettings>
    <Common.Properties.Settings>

    </Common.Properties.Settings>
  </applicationSettings>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
  <loggingConfiguration name="" tracingEnabled="true" defaultCategory="General">
        <listeners>
            <add name="Event Log Listener" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.FormattedEventLogTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.FormattedEventLogTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                source="test Logging" formatter="Text Formatter"
                log="" machineName="." traceOutputOptions="None" />
            <add name="Email Trace Listener" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.EmailTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.EmailTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                toAddress="test@test.com.cn" fromAddress="test@test.com.mo"
                subjectLineStarter="[test] " subjectLineEnder="- DEV"
                smtpServer="smtpserver.test.com.cn" formatter="Text Formatter" />
　　　　　　　　<add name="Database Trace Listener" type="Microsoft.Practices.EnterpriseLibrary.Logging.Database.FormattedDatabaseTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging.Database, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Database.Configuration.FormattedDatabaseTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging.Database, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                databaseInstanceName="TestConnectionString" writeLogStoredProcName="WriteLog"  
                addCategoryStoredProcName="AddCategory" formatter="Text Formatter" traceOutputOptions="None" />
        </listeners>
        <formatters>
            <add type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                template="Timestamp: {timestamp}{newline}
Message: {message}{newline}
Category: {category}{newline}
Priority: {priority}{newline}
EventId: {eventid}{newline}
Severity: {severity}{newline}
Title:{title}{newline}
Machine: {localMachine}{newline}
App Domain: {localAppDomain}{newline}
ProcessId: {localProcessId}{newline}
Process Name: {localProcessName}{newline}
Thread Name: {threadName}{newline}
Win32 ThreadId:{win32ThreadId}{newline}
Extended Properties: {dictionary({key} - {value}{newline})}"
                name="Text Formatter" />
        </formatters>
        <categorySources>
            <add switchValue="All" name="General">
                <listeners>
                    <add name="Event Log Listener" />
                </listeners>
            </add>
            <add switchValue="All" name="Error">
                <listeners>
                    <add name="Event Log Listener" />
                    <add name="Email Trace Listener" />
 　　　　　　　　　　<add name="Database Trace Listener"/>
                </listeners>
            </add>
        </categorySources>
        <specialSources>
            <allEvents switchValue="All" name="All Events" />
            <notProcessed switchValue="All" name="Unprocessed Category" />
            <errors switchValue="All" name="Logging Errors & Warnings">
                <listeners>
                    <add name="Event Log Listener" />
                </listeners>
            </errors>
        </specialSources>
    </loggingConfiguration>
    <exceptionHandling>
        <exceptionPolicies>
            <add name="Exception Policy">
                <exceptionTypes>
                    <add name="All Exceptions" type="System.Exception, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
                        postHandlingAction="NotifyRethrow">
                        <exceptionHandlers>
                            <add name="Logging Exception Handler" type="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging.LoggingExceptionHandler, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                                logCategory="Error" eventId="100" severity="Error" title="Exception Handling"
                                formatterType="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.TextExceptionFormatter, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling"
                                priority="0" />
                        </exceptionHandlers>
                    </add>
                </exceptionTypes>
            </add>
            <add name="Log Only Policy">
                <exceptionTypes>
                    <add name="All Exceptions" type="System.Exception, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
                        postHandlingAction="None">
                        <exceptionHandlers>
                            <add name="Logging Exception Handler" type="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging.LoggingExceptionHandler, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                                logCategory="Error" eventId="100" severity="Error" title="Exception Handling"
                                formatterType="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.TextExceptionFormatter, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling"
                                priority="0" />
                        </exceptionHandlers>
                    </add>
                </exceptionTypes>
            </add>
        </exceptionPolicies>
    </exceptionHandling>
  <system.net>
    <defaultProxy useDefaultCredentials="true">
      <proxy usesystemdefault="False" proxyaddress="http://proxyip:80" bypassonlocal="True" />
    </defaultProxy>
  </system.net>
</configuration>

AppLogger.cs

    public static class AppLogger
    {
        private static Object staticLock = new object();

        static AppLogger()
        {
            Logger.SetLogWriter(new LogWriterFactory().Create());
            IConfigurationSource config = ConfigurationSourceFactory.Create();
            ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);

            ExceptionManager exManager = factory.CreateManager();
            ExceptionPolicy.SetExceptionManager(factory.CreateManager());
        }

        public static void LogError(Exception ex)
        {
            lock (staticLock)
            {

                ExceptionPolicy.HandleException(ex, AppConfiguration.ExceptionPolicyName);
            }
        }

        public static void LogErrorOnly(Exception ex)
        {
            lock (staticLock)
            {
                try
                {
                    ExceptionPolicy.HandleException(ex, AppConfiguration.LogOnlyPolicyName);
                }
                catch(Exception excep) {
                    LogHelper.LogInfo(excep.Message);
                }
            }
        }

        public static bool HandleException(Exception ex, string exceptionPolicyName)
        {
            lock (staticLock)
            {
                return ExceptionPolicy.HandleException(ex, exceptionPolicyName);
            }
        }

        public static void Write(object message)
        {
            lock (staticLock)
            {
                Logger.Write(message);
            }
        }

        public static void Write(object message, string category)
        {
            lock (staticLock)
            {
                Logger.Write(message, category);
            }
        }

        public static void Write(object message, TraceEventType severity)
        {
            lock (staticLock)
            {
                LogEntry entry = new LogEntry();
                entry.Message = message == null ? "" : message.ToString();
                entry.Severity = severity;
                Logger.Write(entry);
            }
        }

        public static void Debug(object message)
        {
            lock (staticLock)
            {
                string msg = string.Format("[{0:yyyy/MM/dd HH:mm:ss.fff}] {1}", DateTime.Now, message);
                try
                {
                    System.Diagnostics.Debug.WriteLine(msg);
                }
                catch (Exception ex)
                {
                    LogErrorOnly(new ApplicationException(string.Format("Could not write debug message: {0}", msg), ex));
                }
            }
        }
    }

LogFormatHelper.cs

    public class LogFormatHelper
    {
        public static string GetMethodDetail(MethodBase method){
                     // MethodBase.GetCurrentMethod().Name;
            StringBuilder methodDetail = new StringBuilder(method.Name); ;
            ParameterInfo[] paras = method.GetParameters();
            StringBuilder parasStr = new StringBuilder();
            foreach (ParameterInfo para in paras)
            {
                parasStr.Append(string.Format("{0} {1},",para.ParameterType.Name.ToString(),para.Name));
            }
            if( paras.Length > 0) parasStr.Remove(parasStr.Length - 1, 1);
            methodDetail.Append("(").Append(parasStr.ToString()).Append(")");
            return methodDetail.ToString();
        }

        public static Dictionary<string, string> GetLogInfo(string methodName)
        {
            Dictionary<string, string> dics = new Dictionary<string, string> { { "MethodName", methodName }, { "SwitchUserPermission", WebHelper.SwitchUserPermission.ToString() }, { "FactoAd", WebHelper.FactoAd }, { "CurrentAd", WebHelper.CurrentAd }, { "TM", WebHelper.CurrentTm } };
            return dics;
        }

        public static Dictionary<string, string> GetLogInfo(string methodName, TimeSpan elapsed)
        {
            Dictionary<string, string> dics = GetLogInfo(methodName);
            dics.Add("RequestElapsed", elapsed.ToString());
            return dics;
        }

        public static void LogServiceError(Exception ex, string methodName, params object[] objs)
        {
            try
            {
                Dictionary<string, string> dics = LogFormatHelper.GetLogInfo(methodName);
                LogServiceError(ex, dics,objs);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogServiceError(Exception ex, string methodName, TimeSpan elapsed, params object[] objs)
        {
            try
            {
                Dictionary<string, string> dics = LogFormatHelper.GetLogInfo(methodName, elapsed);
                LogServiceError(ex, dics, objs);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogServiceError(Exception ex, Dictionary<string, string> dics, params object[] objs)
        {
            try
            {
                AddParametersToError(ex, dics , objs);
                AppLogger.LogError(ex);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogFunction(string functionName)
        {
            try
            {
                AppLogger.Write(functionName);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogFunction(string functionName, TimeSpan elapsed)
        {
            try
            {
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("FunctionName:{0}\r\nFunctionElapsed:{1}\r\n", functionName, elapsed);
                AppLogger.Write(sb);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogRequestParams(string methodName, params object[] objs)
        {
            try
            {
                Dictionary<string, string> dics = GetLogInfo(methodName);
                LogRequestParams(dics, objs);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogRequestParams(string methodName, TimeSpan elapsed , params object[] objs)
        {
            try
            {
                Dictionary<string, string> dics = GetLogInfo(methodName, elapsed);
                LogRequestParams(dics, objs);
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogRequestParams(Dictionary<string,string> dics,  params object[] objs)
        {
            try
            {
                StringBuilder sb = new StringBuilder();
                foreach (var dic in dics)
                {
                    sb.AppendFormat("{0} = {1}", dic.Key, dic.Value).AppendLine();
                    //LogRequestParams(obj);
                }
                sb.Append("Other objects =").AppendLine();
                foreach (object obj in objs)
                {
                    LogRequestParams(sb ,obj);
                }
                AppLogger.Write(sb.ToString());
            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void LogRequestParams(StringBuilder sb,object obj)
        {
            try
            {
                Dictionary<string, object> result = BuildParametersDictionary(obj, "");
             //   StringBuilder sb = new StringBuilder();
             //   if (elapsed != null) sb.AppendFormat("Request Elapsed: {0}", elapsed).AppendLine();
                sb.AppendFormat("{0}:", obj.GetType().Name).AppendLine();
                foreach (var p in result)
                {
                    sb.AppendFormat("{0} = {1}", p.Key, p.Value).AppendLine();
                }

            }
            catch (Exception innerExp)
            {
                innerExp.Data.Add("Logger error", innerExp.Message);
                AppLogger.LogError(innerExp);
            }
        }

        public static void AddParametersToError(Exception ex, Dictionary<string,string> dics ,params object[] objs)
        {
            foreach (var dic in dics)
           {
                ex.Data.Add(dic.Key, dic.Value);
           }

           foreach (object obj in objs)
           {
                 AddParametersToError(ex,obj,"");
           }

        }

        public static void AddParametersToError(Exception ex, object obj, string propertyNamePrefix)
        {
            if (obj == null)
                return;

            Dictionary<string, object> parameters = BuildParametersDictionary(obj, propertyNamePrefix);
            foreach (var p in parameters)
            {
                ex.Data.Add(p.Key, p.Value);
            }
        }

        private static Dictionary<string, object> BuildParametersDictionary(object obj, string propertyNamePrefix)
        {
            Dictionary<string, object> result = new Dictionary<string, object>();
            if (obj == null)
                return result;

            if (obj is string || obj is DateTime || obj is Boolean)
            {
                result.Add(obj.GetType().ToString(), obj.ToString());
                return result;
            }

            var properties = obj.GetType().GetProperties();
            foreach (PropertyInfo p in properties)
            {
                Type pType = p.GetType();
                object pValue = p.GetValue(obj, null);
                if (pValue == null)
                {
                    string pName = string.IsNullOrEmpty(propertyNamePrefix) ? p.Name : propertyNamePrefix + "." + p.Name;
                    result.Add(pName, "null");
                }
                else if (pType.IsValueType || pValue is string || pValue is DateTime || pValue is Boolean)
                {
                    string pName = string.IsNullOrEmpty(propertyNamePrefix) ? p.Name : propertyNamePrefix + "." + p.Name;
                    if (p.Name.ToLower() == "password" || p.Name.ToLower() == "dateofbirth" || p.Name.ToLower() == "encrykey")
                        result.Add(pName, "******");
                    else
                        result.Add(pName, pValue);
                }
                else if (pType.FullName.Contains(typeof(List<>).FullName))
                {
                    var list = obj as System.Collections.ICollection;
                    if (list != null && list.Count > 0)
                    {
                        int index = 0;
                        foreach (object objInList in list)
                        {
                            if (objInList is ValueType || objInList is string)
                                result.Add(p.Name + "[" + index.ToString() + "]", objInList);
                            else
                            {
                                Dictionary<string, object> childResult = BuildParametersDictionary(objInList, p.Name + "[" + index.ToString() + "]");
                                foreach (var e in childResult)
                                {
                                    result.Add(e.Key, e.Value);
                                }
                            }
                            index++;
                        }
                    }
                }
                else if (pValue.GetType().FullName.Contains(typeof(List<>).FullName))
                {
                    var list = pValue as System.Collections.ICollection;
                    if (list != null && list.Count > 0)
                    {
                        int index = 0;
                        foreach (object objInList in list)
                        {
                            if (objInList is ValueType || objInList is string)
                                result.Add(p.Name + "[" + index.ToString() + "]", objInList);
                            else
                            {
                                Dictionary<string, object> childResult = BuildParametersDictionary(objInList, p.Name + "[" + index.ToString() + "]");
                                foreach (var e in childResult)
                                {
                                    result.Add(e.Key, e.Value);
                                }
                            }
                            index++;
                        }
                    }
                }
            }
            return result;
        }
    }

string methodName =  LogFormatHelper.GetMethodDetail(MethodBase.GetCurrentMethod());
           LogFormatHelper.LogRequestParams(methodName, objectname);