使用Microsoft.ApplicationBlocks.ExceptionManagement处理程序异常

详细文档看:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnbda/html/emab-rm.asp
说明几点:
文件夹:Microsoft.ApplicationBlocks.ExceptionManagement
为异常主类文件.
Microsoft.ApplicationBlocks.ExceptionManagement.Interfaces
为异常接口类文件,
安装
1.使用installutil安装DLL文件,
安装方法,
Visual Studio .NET 2003 命令提示+installutil Microsoft.ApplicationBlocks.ExceptionManagement.dll所有路径
如:installutil E:\exception\Microsoft.ApplicationBlocks.ExceptionManagement\bin\Debug\Microsoft.ApplicationBlocks.ExceptionManagement.dll
程序使用:
添加对Microsoft.ApplicationBlocks.ExceptionManagement.dll引用,
在配制文件添加配制

  < configSections >
             < section  name ="exceptionManagement"  type ="Microsoft.ApplicationBlocks.ExceptionManagement.ExceptionManagerSectionHandler,Microsoft.ApplicationBlocks.ExceptionManagement"   />
         </ configSections >
         < exceptionManagement  mode ="on" >     
                <!--使用自定义数据记录使用下面配制-->
            <!-- < publisher  mode ="on"  
                assembly ="Microsoft.ApplicationBlocks.ExceptionManagement"   
                type ="Edobnet.FrameWork.ExceptionHandler.ExceptionDBPublisher"
                connString ="USER ID=sa;PASSWORD=232323;INITIAL CATALOG=Errors;DATA SOURCE=localhost"   />-->
         <!--使用自定义数据记录使用下面配制-->   
            <!--< publisher  mode ="on"  
                    assembly ="Microsoft.ApplicationBlocks.ExceptionManagement"   
                    type ="Edobnet.FrameWork.ExceptionHandler.ExceptionLogPublisher"  
                    fileName ="philips.log"
                    filePath ="C:"
                    stackTrace  = "true"
                    daily ="true"   />
                    -->
         </ exceptionManagement >

添加USING
using Microsoft.ApplicationBlocks.ExceptionManagement;

测试代码:

try
             {
                int t = 0;
                int i = 1/t;
            }
             catch (Exception ex)
             {
                ExceptionManager.Publish( ex );

            }

如果不使用自己定议异常处理,只会在WINDOWS事件里记录,

自定义异常处理:

using  System;
using  System.IO;
using  System.Text;
using  System.Data;
using  System.Data.SqlClient;
using  System.Collections;
using  System.Collections.Specialized;
using  Microsoft.ApplicationBlocks.ExceptionManagement;

namespace  Edobnet.FrameWork.ExceptionHandler
{
    /**//// <summary>
    /// <para>
    /// This ExceptionDBPublisher class is a custom publisher for the
    /// Microsoft Exception Management Application Block.
    /// </para><para>
    /// It writes Exception info to a database including
    /// Message, Source and Stack Trace.
    /// </para>
    /// </summary>
    /// <remarks>
    /// <para>This class is a custom publisher for the
    /// Microsoft Exception Management Application Block.
    /// Note that the Stored Procedure spLogError and table
    /// ErrorLog must exist in the database.
    /// It writes Exception info to a database including:
    /// <list type="bullet">
    /// <item><term>Message</term>
    /// <description>Exception Message</description></item>
    /// <item><term>Source</term>
    /// <description>The Exception source</description></item>
    /// <item><term>StackTrace</term>
    /// <description>The Stack Trace</description></item></list>
    /// </para>
    /// <para>
    /// Configuration Parameters and examples:
    /// <list type="bullet">
    /// <item>
    /// <term>assembly</term>
    /// <description>assembly file name: assembly="[Dll name without '.dll']"</description>
    /// </item>
    /// <item>
    /// <term>type</term>
    /// <description>class and namespace: type="[Fully qualified namespace and type]"</description>
    /// </item>
    /// <item>
    /// <term>connString</term>
    /// <description>Connection String: connString="db_connect_string"</description>
    /// </item>
    /// </list>
    /// </para>
    /// <para>
    ///    For more information see documentation on MS Exception Management
    ///    Application Blocks</para>
    ///    <example>Here is an example entry under &lt;exceptionManagement&gt;"
    ///    <code>
    ///    &lt;publisher mode="on" 
    /// assembly="Com.Daveranck.ExceptionHandler"  
    /// type="Com.Daveranck.ExceptionHandler.ExceptionDBPublisher"
    /// connString="server=[Server Name];Integrated Security=SSPI;Database=[Database]" /&gt;
    ///    </code>
    ///    </example>
    ///    </remarks>
    public class ExceptionDBPublisher : IExceptionPublisher
    {
        /**//// <summary>
        /// The database connection string must be set in config file
        /// </summary>
        // MUST be set in config file 
        private string m_ConnString = @"";
        /**//// <summary>
        /// Constructor
        /// </summary>
        public ExceptionDBPublisher()
        {
        }

        /**//// <summary>
        /// Sets up the config settings from the app
        /// config file, if available. Otherewise,
        /// defaults are used.
        /// </summary>
        private void SetConfig(NameValueCollection configSettings)
        {
            // Load Config values if they are provided.
            if (configSettings != null)
            {
                if (configSettings["connString"] != null &&  
                    configSettings["connString"].Length > 0)
                {  
                    m_ConnString = configSettings["connString"];
                }
            }
        }

        /**//// <summary>
        /// Provide implementation of the IExceptionPublisher interface
        /// This contains the single Publish method.
        /// <param name="exception">Exception</param>
        /// <param name="additionalInfo">NameValuecollection</param>
        /// <param name="configSettings">NameValuecollection</param>
        /// </summary>
        void IExceptionPublisher.Publish(Exception exception, 
            NameValueCollection additionalInfo, 
            NameValueCollection configSettings)
        {
            // Load config settings if available
            SetConfig(configSettings);

            // Create StringBuilder to maintain publishing information.
            StringBuilder strInfo = new StringBuilder();

            // Record the contents of the additionalInfo collection.
            if (additionalInfo != null)
            {
                // Record General information.
                strInfo.AppendFormat("{0}General Information {0}", Environment.NewLine);
                strInfo.AppendFormat("{0}Additonal Info:", Environment.NewLine);
                foreach (string i in additionalInfo)
                {
                    strInfo.AppendFormat("{0}{1}: {2}", Environment.NewLine, i, 
                        additionalInfo.Get(i));
                }
            }
            // Log to database
            LogInDatabase(strInfo.ToString(),
                exception.Message,
                exception.Source,
                exception.StackTrace);
        }

        /**//// <summary>
        /// <para>This method will publish the Exception Message,
        /// Source and Stack Trace to a database.</para>
        /// </summary>
        /// <param name="Info">General exception info</param>
        /// <param name="Message">Excaption Mesage</param>
        /// <param name="Source">Exception Source</param>
        /// <param name="StackTrace">Exception Stack Trace</param>
        private void LogInDatabase(string Info, 
            string Message,
            string Source,
            string StackTrace)
        {
            // Create connection
            SqlConnection sqlConn = new SqlConnection();
            sqlConn.ConnectionString = m_ConnString;

            string spName = "spLogError";

            SqlCommand sqlCmd = new SqlCommand(spName, sqlConn);
            sqlCmd.CommandType = CommandType.StoredProcedure;

            // Add params
            SqlParameter pInfo = sqlCmd.Parameters.Add("@Info",    SqlDbType.VarChar, 500);
            pInfo.Value = Info;
            SqlParameter pMessage = sqlCmd.Parameters.Add("@Message",    SqlDbType.VarChar, 500);
            pMessage.Value = Message;
            SqlParameter pSource = sqlCmd.Parameters.Add("@Source",    SqlDbType.VarChar, 255);
            pSource.Value = Source;
            SqlParameter pStackTrace = sqlCmd.Parameters.Add("@StackTrace",    SqlDbType.VarChar, 1000);
            pStackTrace.Value = StackTrace;

            // Log error
            try
            {
                sqlConn.Open();
                int result = sqlCmd.ExecuteNonQuery();
            }
            catch(Exception ex)
            {
                // Database problem rethrow exception
                // Exception Manager will log original exception
                // and this exception to Event log
                throw ex;
            }
            finally
            {
                // Clean up
                if (sqlConn.State != System.Data.ConnectionState.Closed &&
                    sqlConn.State != System.Data.ConnectionState.Broken)
                {
                    sqlConn.Close();
                }
            }
        }
    }

    /**//// <summary>
    /// <para>The ExceptionLogPublisher class is a custom publisher for the
    /// Microsoft Exception Management Application Block.
    /// </para><para>
    /// It writes exception info to a logfile including:
    /// Message and optionally Source and StackTrace.
    /// </para>
    /// </summary>
    /// <remarks>
    /// <para>Configuration Parameters and examples:
    /// <list type="bullet">
    /// <item>
    /// <term>assembly</term>
    /// <description>assembly file name: assembly="[Dll name without '.dll']"</description>
    /// </item>
    /// <item>
    /// <term>type</term>
    /// <description>class and namespace: type="[Fully qualified namespace and type]"</description>
    /// </item>
    /// <item>
    /// <term>fileName</term>
    /// <description>log file name: "myLogFile.txt"</description>
    /// </item>
    /// <item>
    /// <term>filePath</term>
    /// <description>path to log file location (including trailing ""): "c:logs</description>
    /// </item>
    /// <item>
    /// <term>stackTrace</term>
    /// <description>true or false - if true, stack trace included in log</description>
    /// </item>
    /// <item>
    /// <term>daily</term>
    /// <description>true or false - if true, new log created each day and date 
    /// preppended to the fileName Ex: 20031114myLogFile.log</description>
    /// </item>
    /// </list> 
    ///    <para>For more information see documentation on MS Exception Management
    ///    Application Blocks</para>
    ///    </para>
    ///    <example>Here is an example entry under &lt;exceptionManagement&gt;
    ///    <code>
    ///    &lt;publisher mode="on" 
    /// assembly="Com.Daveranck.ExceptionHandler"  
    /// type="Com.Daveranck.ExceptionHandler.ExceptionLogPublisher" 
    /// fileName="AppExceptionLog.txt"
    /// filePath="c:"
    /// stackTrace = "true"
    /// daily="true" /&gt;
    ///    </code>
    ///    </example>
    ///    </remarks>

    public class ExceptionLogPublisher : IExceptionPublisher
    {
        // defaults if no parameteres given
        private string m_LogName = @"ErrorLog.txt";
        private string m_LogPath = @"C:";
        private bool m_dailyLog = false;
        private bool m_stackTrace = false;
        
        /**//// <summary>
        /// Constructor
        /// </summary>
        public ExceptionLogPublisher()
        {
        }

        /**//// <summary>
        /// Sets up the config settings from the app
        /// config file, if available. Otherewise,
        /// defaults are used.
        /// </summary>
        private void SetConfig(NameValueCollection configSettings)
        {
            // Load Config values if they are provided.
            if (configSettings != null)
            {
                if (configSettings["fileName"] != null &&  
                    configSettings["fileName"].Length > 0)
                {  
                    m_LogName = configSettings["fileName"];
                }
                if (configSettings["filePath"] != null &&  
                    configSettings["filePath"].Length > 0)
                {  
                    m_LogPath = configSettings["filePath"];
                }
                if(configSettings["daily"] != null &&
                    configSettings["daily"].Equals("true"))
                {
                    m_dailyLog = true;
                }
                if(configSettings["stackTrace"] != null &&
                    configSettings["stackTrace"].Equals("true"))
                {
                    m_stackTrace = true;
                }
            }
        }

        /**//// <summary>
        /// Crestes the file path to write the log file to.
        /// If Daily has been set to true in config settings,
        /// will prepend the date (yyyymmdd) to the filename,
        /// allowing the file to rollover daily.
        /// </summary>
        /// <returns>string Filename and path</returns>
        private string CreateLogFilePath()
        {
            if(m_dailyLog == true)
            {
                //Add date header to filename
                DateTime dt = DateTime.Today;
                StringBuilder newLogName = new StringBuilder();
                newLogName.Append(dt.Year.ToString());
                newLogName.Append(dt.Month.ToString());
                newLogName.Append(dt.Day.ToString());
                newLogName.Append(m_LogName);
                m_LogName = newLogName.ToString();
                
            }
            string logFilePath = m_LogPath + m_LogName;
            return logFilePath;
        }

        /**//// <summary>
        /// Creates the message to be logged from the Exception.
        /// Will add additional info if it exists and if
        /// stackTrace is true in config settings, will append stack trace
        /// and source to the message.
        /// </summary>
        /// <returns>string message to log</returns>
        private string CreateLogMessage(Exception exception, 
            NameValueCollection additionalInfo)
        {
            // Create StringBuilder to maintain publishing information.
            StringBuilder strInfo = new StringBuilder();

            // Record the contents of the additionalInfo collection.
            if (additionalInfo != null)
            {
                // Record General information.
                strInfo.AppendFormat("{0}General Information {0}", Environment.NewLine);
                strInfo.AppendFormat("{0}Additonal Info:", Environment.NewLine);
                foreach (string i in additionalInfo)
                {
                    strInfo.AppendFormat("{0}{1}: {2}", Environment.NewLine, i, 
                        additionalInfo.Get(i));
                }
            }

            // Append the exception text including:
            // Message and if stackTrace = true, Source and Stack Trace
            if ( exception != null )
            {
                strInfo.AppendFormat("{0}Exception Information {1}",
                    Environment.NewLine, exception.Message.ToString() + Environment.NewLine); 
                //Append Source and Stacktrace
                if(m_stackTrace == true)
                {
                    strInfo.Append(Environment.NewLine + "Source: ---- " + Environment.NewLine 
                        + exception.Source + Environment.NewLine); 
                    strInfo.Append(Environment.NewLine + "Stack Trace: ---- " 
                        + Environment.NewLine + exception.StackTrace);
                }
                strInfo.Append(Environment.NewLine 
                    + "------------------------------------------------------------" 
                    + Environment.NewLine + Environment.NewLine);
            }
            else
            {
                strInfo.AppendFormat("{0}{0}No Exception.{0}", Environment.NewLine);
            }
            return strInfo.ToString();
        }

        /**//// <summary>
        /// Provide implementation of the IExceptionPublisher interface
        /// This contains the single Publish method.
        /// <para>Logs the Exception Message, Source and Stack Trace</para>
        /// </summary>
        /// <param name="exception">Exception</param>
        /// <param name="additionalInfo">NameValuecollection</param>
        /// <param name="configSettings">NameValuecollection</param>
        void IExceptionPublisher.Publish(Exception exception, 
            NameValueCollection additionalInfo, 
            NameValueCollection configSettings)
        {
            // Read and set up configuration
            SetConfig(configSettings);

            // Create fileName
            string logFilePath = CreateLogFilePath();

            // Create Message
            string logMessage = CreateLogMessage(exception, additionalInfo);

            // Write the entry to the log file. 
            try
            {
                // Append to file if exists or create new file
                using ( FileStream fs = File.Open(logFilePath,
                            FileMode.Append,FileAccess.Write))
                {
                    using (StreamWriter sw = new StreamWriter(fs))
                    {
                        sw.Write(logMessage);
                    }
                }
            }
            catch(Exception ex)
            {
                // Error writing exception.
                // Exception Manager will log original exception
                // and this exception to Event log
                throw ex;
            }
        }
    }
}

数据库异常的数据表如下:

if   exists  ( select   *   from  dbo.sysobjects  where  id  =   object_id (N ' [dbo].[ErrorLog] ' )  and   OBJECTPROPERTY (id, N ' IsUserTable ' )  =   1 )
drop   table   [ dbo ] . [ ErrorLog ]
GO

CREATE   TABLE   [ dbo ] . [ ErrorLog ]  (
     [ ID ]   [ numeric ] ( 18 ,  0 )  IDENTITY  ( 1 ,  1 )  NOT   NULL  ,
     [ Info ]   [ varchar ]  ( 500 )  NOT   NULL  ,
     [ Message ]   [ varchar ]  ( 500 )   NULL  ,
     [ Source ]   [ varchar ]  ( 255 )   NULL  ,
     [ StackTrace ]   [ varchar ]  ( 1000 )   NULL  ,
     [ EntryDateTime ]   [ datetime ]   NOT   NULL  
)  ON   [ PRIMARY ]
GO

if   exists  ( select   *   from  dbo.sysobjects  where  id  =   object_id (N ' [dbo].[spLogError] ' )  and   OBJECTPROPERTY (id, N ' IsProcedure ' )  =   1 )
drop   procedure   [ dbo ] . [ spLogError ]
GO

SET  QUOTED_IDENTIFIER  OFF  
GO
SET  ANSI_NULLS  OFF  
GO

/**/ /*********************************************************************************************************************************************************************************************
    Name:            spLogError
    Author:            Dave Ranck
    Date:            11/14/2003

    Purpose:        This procedure logs exception info. 

    Parameters:        @Info
                @Message
                @Source
                @StackTrace
        
/*********************************************************************************************************************************************************************************************/
*/
CREATE   PROCEDURE  spLogError
@Info  varchar ( 500 ),
@Message  varchar ( 500 ),
@Source  varchar ( 255 ),
@StackTrace  varchar  ( 2000 )


AS
INSERT   INTO  ErrorLog(Info, Message, Source, StackTrace, EntryDateTime) 

VALUES (@Info, @Message, @Source, @StackTrace,  GetDate ())
GO
SET  QUOTED_IDENTIFIER  OFF  
GO
SET  ANSI_NULLS  ON  
GO

设定相应的异常通过CONFIG文件来设置,我在接面有相应的例子.