asp.net mvc实现 错误异常记录功能

最新推荐文章于 2022-04-26 11:40:14 发布
最新推荐文章于 2022-04-26 11:40:14 发布
阅读量449 收藏 1
点赞数
分类专栏： asp.net MVC C# 文章标签： 错误日志 自定义
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxf359/article/details/77663454
版权

创建LogExceptionAttribute 类，继承HandleErrorAttribute 错误异常过滤器

using System;
using System.Web.Mvc;

namespace SXF.Utils.MVC
{
    /// <summary>
    /// 错误日志记录
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
    public class LogExceptionAttribute : HandleErrorAttribute
    {
        public override void OnException(ExceptionContext filterContext)
        {
            if (!filterContext.ExceptionHandled)
            {
                #region 记录错误日志
                string controllerName = (string)filterContext.RouteData.Values["controller"];
                string actionName = (string)filterContext.RouteData.Values["action"];
                string msgTemplate = string.Format("在执行 controller[{0}] 的 action[{1}] 时产生异常", controllerName, actionName);
                EventLog.LogItem item = new EventLog.LogItem();
                item.Title = msgTemplate;
                LogManage.WriteException(filterContext.Exception, item);
                #endregion
            }
            base.OnException(filterContext);
        }
    }
}

此方法中用到了EventLog类中的方法，代码如下： 

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.IO;
using System.Text;
using System.Web;

namespace SXF.Utils
{
    /// <summary>
    /// 写日志
    /// 不想自动记录Context信息请调用Log(string message, string typeName, false)
    /// </summary>
    public class EventLog
    {
        /// <summary>
        /// 是否使用上下文信息写日志
        /// </summary>
        static bool UseContext = true;
        static string _thisDomain = "";


        #region LogItem
        [Serializable]
        public class LogItem
        {
            public DateTime Time
            {
                get;
                set;
            }
            public string Title
            {
                get;
                set;
            }
            public string Detail
            {
                get;
                set;
            }
            public string RequestUrl
            {
                get;
                set;
            }
            public string UrlReferrer
            {
                get;
                set;
            }
            public string HostIP
            {
                get;
                set;
            }
            public string UserAgent
            {
                get;
                set;
            }
            public override string ToString()
            {
                string s = Time.ToString("yyyy-MM-dd HH:mm:ss");
                if (string.IsNullOrEmpty(Title))
                {
                    Title = Detail;
                    Detail = "";
                }
                if (!string.IsNullOrEmpty(Title))
                {
                    s += "  " + Title;
                }
                if (!string.IsNullOrEmpty(RequestUrl))
                {
                    s += "\r\nUrl:" + RequestUrl;
                }
                if (!string.IsNullOrEmpty(UrlReferrer))
                {
                    s += "\r\nUrlReferrer:" + UrlReferrer;
                }
                if (!string.IsNullOrEmpty(HostIP))
                {
                    s += "\r\nHostIP:" + HostIP;
                }
                if (!string.IsNullOrEmpty(UserAgent))
                {
                    s += "\r\n" + UserAgent;
                }
                if (!string.IsNullOrEmpty(Detail))
                {
                    s += "\r\n" + Detail;
                }
                s += "\r\n";
                return s;
            }
        }
        #endregion


        static object lockObj = new object();
        /// <summary>
        /// 检查目录并建立
        /// </summary>
        /// <param name="path"></param>
        public static void CreateFolder(string path)
        {
            if (path.IsNullOrEmpty())
            {
                return;
            }
            string folder = "";
            string[] arry = path.Split('\\');
            for (int i = 0; i < arry.Length; i++)
            {
                folder += arry[i] + "\\";
                if (!Directory.Exists(folder))
                    Directory.CreateDirectory(folder);
            }
        }
        /// <summary>
        /// 自定义文件名前辍写入日志
        /// </summary>
        /// <param name="message"></param>
        /// <param name="typeName"></param>
        /// <param name="useContext"></param>
        /// <returns></returns>
        public static bool Log(string message, string typeName, bool useContext)
        {
            LogItem logItem = new LogItem();
            logItem.Detail = message;
            return Log(logItem, typeName, useContext);
        }
        public static bool Log(string message, string typeName)
        {
            return Log(message, typeName, true);
        }
        /// <summary>
        /// 指定日志类型名生成日志
        /// </summary>
        /// <param name="logItem"></param>
        /// <param name="typeName"></param>
        /// <returns></returns>
        public static bool Log(LogItem logItem, string typeName)
        {
            return Log(logItem, typeName, true);
        }
        /// <summary>
        /// 指定日志类型名生成日志
        /// </summary>
        /// <param name="logItem"></param>
        /// <param name="typeName"></param>
        /// <param name="useContext">是否使用当前上下文信息</param>
        /// <returns></returns>
        public static bool Log(LogItem logItem, string typeName, bool useContext)
        {
            string fileName = DateTime.Now.ToString("yyyy-MM-dd");
            if (!string.IsNullOrEmpty(typeName))
            {
                fileName += "." + typeName;
            }
            HttpContext context = HttpContext.Current;
            logItem.Time = DateTime.Now;

            if (context != null)
            {
                try
                {
                    if (string.IsNullOrEmpty(_thisDomain))
                    {
                        _thisDomain = context.Request.Url.Host;
                    }
                    if (UseContext)
                    {
                        if (useContext)
                        {
                            logItem.HostIP = RequestHelper.GetCdnIP();

                            logItem.RequestUrl = context.Request.Url.ToString();
                            logItem.UserAgent = context.Request.UserAgent;
                            logItem.UrlReferrer = context.Request.UrlReferrer + "";
                        }
                    }
                }
                catch
                {
                }
            }
            return WriteLog(GetLogFolder(), logItem, fileName);
        }
        /// <summary>
        /// 生成日志,默认文件名
        /// </summary>
        /// <param name="message"></param>
        /// <param name="sendToServer">是否发送到服务器</param>
        /// <returns></returns>
        public static bool Log(string message, bool sendToServer)
        {
            //if (sendToServer)
            //{
            //    SendToServer(message, "");
            //}
            return WriteLog(message);
        }
        /// <summary>
        /// 生成日志,默认文件名
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool Log(string message)
        {
            return WriteLog(message);
        }
        /// <summary>
        /// 生成日志,文件名以Error开头
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool Error(string message)
        {
            return Log(message, "Error");
        }
        /// <summary>
        /// 生成日志,文件名以Info开头
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool Info(string message)
        {
            return Log(message, "Info");
        }
        /// <summary>
        /// 生成日志,文件名以Debug开头
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool Debug(string message)
        {
            return Log(message, "Debug");
        }
        /// <summary>
        /// 在当前网站目录生成日志
        /// </summary>
        /// <param name="message"></param>
        public static bool WriteLog(string message)
        {
            return Log(message, "");
        }


        static bool Writing = false;
        //static DateTime lastWriteTime = DateTime.Now;
        static Dictionary<string, LogItemArry> logCaches = new Dictionary<string, LogItemArry>();
        static System.Timers.Timer timer;
        private static void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (!Writing)
            {
                WriteLogFromCache();
            }

        }
        /// <summary>
        /// 指定路径,文件名,写入日志
        /// </summary>
        /// <param name="path"></param>
        /// <param name="logItem"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static bool WriteLog(string path, LogItem logItem, string fileName)//建立日志
        {
            try
            {
                if (timer == null)
                {
                    timer = new System.Timers.Timer();
                    timer.Interval = 2000;
                    timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
                    timer.Start();
                }
                if (!System.IO.Directory.Exists(path))
                    CreateFolder(path);
                string filePath = "";

                filePath = path + fileName + ".txt";

                if (!logCaches.ContainsKey(filePath))
                    logCaches.Add(filePath, new LogItemArry() { savePath = filePath });

                logCaches[filePath].Add(logItem);
                return true;
            }
            catch
            {
                return false;
            }
        }
        public static string LastError;
        public static void WriteLogFromCache()
        {
            lock (lockObj)
            {
                Writing = true;
                //累加上次记录的日志
                if (logCaches.Count > 0)
                {
                    Dictionary<string, LogItemArry> list = new Dictionary<string, LogItemArry>(logCaches);
                    foreach (KeyValuePair<string, LogItemArry> entry in list)
                    {
                        LogItemArry logitemArry = entry.Value;
                        LastError = null;
                        try
                        {
                            WriteLine(logitemArry.ToString(), entry.Key);
                        }
                        catch (Exception ero)
                        {
                            LastError = ero.ToString();
                        }
                        logCaches.Remove(entry.Key);
                    }
                }
                //System.Threading.Thread.Sleep(6000);
                Writing = false;
            }
        }


        /// <summary>
        /// 写信息到指定文件
        /// </summary>
        /// <param name="message"></param>
        /// <param name="filePath"></param>
        private static void WriteLine(string message, string filePath)
        {

            using (FileStream fs = File.OpenWrite(filePath))
            {
                //根据上面创建的文件流创建写数据流
                StreamWriter w = new StreamWriter(fs, System.Text.Encoding.Default);
                //设置写数据流的起始位置为文件流的末尾
                w.BaseStream.Seek(0, SeekOrigin.End);
                //w.Write(DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
                w.Write(message);
                w.Flush();
                w.Close();
            }
            Console.WriteLine(message);
        }
        static string secondFolder = null;
        /// <summary>
        /// 获取日志二级目录
        /// </summary>
        /// <returns></returns>
        public static string GetSecondFolder()
        {
            if (secondFolder == null)
            {
                string address = RequestHelper.GetServerIp();

                string[] arry = address.Split('.');
                secondFolder = arry[arry.Length - 1];
            }
            return secondFolder;
        }
        static string rootPath = null;
        /// <summary>
        /// 获取日志绝对目录
        /// </summary>
        /// <returns></returns>
        public static string GetLogFolder()
        {
            if (rootPath == null)
            {
                rootPath = System.Web.Hosting.HostingEnvironment.MapPath(@"\log\");
                if (string.IsNullOrEmpty(rootPath))
                {
                    rootPath = AppDomain.CurrentDomain.BaseDirectory + @"\log\";
                }
                rootPath += GetSecondFolder() + @"\";
                //如果节点有设置,则按节点设置读取
                NameValueCollection appSettings = ConfigurationManager.AppSettings;
                string settingPath = appSettings["EventLogFolder"];
                if (!string.IsNullOrEmpty(settingPath))
                {
                    rootPath = settingPath + @"\";
                }
            }
            return rootPath;
        }


        /// <summary>
        /// 项集合
        /// </summary>
        public class LogItemArry
        {
            public string savePath;
            List<LogItem> logs = new List<LogItem>();
            public void Add(LogItem log)
            {
                logs.Add(log);
            }
            public override string ToString()
            {
                StringBuilder sb = new StringBuilder();
                foreach (LogItem item in logs)
                {
                    sb.Append(item.ToString());
                }
                return sb.ToString() + "\r\n";
            }
        }
    }
}

用到了LogManage 类的方法，代码如下： 

using System;
using System.Text;
using System.Web;


namespace SXF.Utils.MVC
{
    /// <summary>
    /// mvc日志管理
    /// </summary>
    public class LogManage
    {
        public static Exception GetInnerException(Exception exp)
        {
            if (exp.InnerException != null)
            {
                exp = exp.InnerException;
                return GetInnerException(exp);
            }
            return exp;
        }

        static long exceptionId = 0;
        static object lockObj = new object();


        /// <summary>
        /// 内部记录日志
        /// </summary>
        /// <param name="ero"></param>
        /// <returns></returns>
        static string InnerLogException(Exception ero, EventLog.LogItem item)
        {
            string host = HttpContext.Current.Request.Url.Host.ToUpper();
            string errorCode = host.Replace(".", "_");
            lock (lockObj)
            {
                exceptionId += 1;
                errorCode += ":" + EventLog.GetSecondFolder() + ":" + exceptionId;
            }

            ero = GetInnerException(ero);


            item.Title = item.Title + ",错误代码:" + errorCode;
            if (ero != null)
            {
                item.Detail = ero.Message + "\r\n" + ero.StackTrace + "\r\n";
            }
            EventLog.Log(item, "Error");
            if (host == "LOCALHOST")
            {
                return errorCode;
            }


            return errorCode;
        }

        /// <summary>
        /// 页面输出并写入错误日志
        /// </summary>
        /// <param name="ero"></param>
        public static void WriteException(Exception ero, EventLog.LogItem item)
        {
            //EventLog.Log("start1", "error");
            bool logError = true;
            if (ero is HttpException)
            {
                HttpException he = ero as HttpException;
                int code = he.GetHttpCode();
                if (code == 404)
                {
                    logError = false;
                }
            }
            if (ero is HttpRequestValidationException)
            {
                logError = false;
            }
            //EventLog.Log("start2", "error");
            string errorCode = string.Empty;
            if (logError)
            {
                //EventLog.Log("start6", "error");
                errorCode = InnerLogException(ero, item);
            }

        }



    }
}

写好后需要在FilterConfig 中注册： 

public static class FilterConfig
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            //错误处理
            filters.Add(new HandleErrorAttribute());
            //日志记录
            filters.Add(new SXF.Utils.MVC.LogExceptionAttribute());
           
        }
    }

global.asax.cs中已经在application_start中默认有调用代码： 

FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);

另外 web.config 中设置： 

<customErrors mode="Off" />


这样就设置好了，一旦在网站中出现mvc 错误，会在网站根目录的 log 文件夹下，自动创建一个类似这样的txt 日志文件：2017-08-02.Error.txt ，每天都会创建一个。若没创建，要么是没有log 文件夹，要么是log 文件夹网站默认用户没创建文件及文件夹的权限

sxf359
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ASP.NET MVC5 编程实战.pdf
10-30
ASP.NET MVC5 是微软开发的一款用于构建Web应用程序的框架，它结合了模型-视图-控制器（MVC）设计模式、ASP.NET Web Forms组件以及Web API功能，为开发者提供了更灵活、可测试的Web开发解决方案。这本书《ASP.NET ...
ASP.NET MVC中异常处理&自定义错误页详析
01-02
对于B/S应用程序,在部署到正式环境运行的过程中,很有可能出现一些在前期测试过程中没有发现的一些异常或者错误,或者说只有在特定条件满足时才会发生的一些异常,对于使用ASP.NET MVC开发的应用程序站点，在部署到IIS...
【MVC】错误页面设置和错误信息记录
gx_up
08-15 2600
一、自定义错误页面   有些时候，我们想使用自定义的错误页面，该怎么处理那。 翻页其他大牛写的博客，看到有这种方式，自定义属性Class继承FileterAttribute， 重写OnException方法，代码如下 public class MyErrorAttribute: HandleErrorAttribute { public override
ASP.NET MVC中错误处理方式
zp19860529的博客
03-10 597
aspnet mvc的错误处理方式主要有以下两种 方式一：通过对controller或者action标记HandleError属性，然后指定一个错误页即可。这种方式最简单，不需要额外增加action ，仅仅需要增加错误页，但是不能记录日志(因为没有action，其实在aspx中也可调用记录日志的方法)。这个错误页还可以定义为强类型，类型为HandleErrorInfo,具体的Model又框架传递，可获取具体的异常信息。 ///<summary> ///标记了Hand...
爱上MVC3系列~全局异常处理与异常日志
weixin_34337381的博客
06-15 72
回到目录 在ＭＶＣ３网站的global.asax中的Application_Start方法里，有这样一段代码　 1 RegisterGlobalFilters(GlobalFilters.Filters); 它的主要使用是将全局过滤器进行注册，而全局过滤器可以在RegisterGlobalFilters这个方法里进行设置，如代码： 1 /// &lt;summary...
WinForm、ASP.NET、MVC记录全局错误日志
行成于思毁于随
02-24 5526
之前我转载了一篇“C#使用Log4Net记录日志”，但如果是错误日志，则没必要在每个方法里面捕获异常再记录日志，这时我们写一个全局的错误日志记录方法就行了，但这全局到底应该写在哪呢？ 不同的项目写的地方是不一样的：WinForm、ASP.NET、MVC WinForm：在Program.cs文件里 /// /// 应用程序的主入口点。 /
ASP.NET MVC 利用IExceptionFilter实现异常统一处理
落花流水
03-22 1177
ASP.NET MVC异常过滤器的定义和应用
asp net mvc 全局捕获异常的方法
guigenyi的专栏
04-26 1071
在一个网站的开发测试阶段，我们经常需要全局捕获异常。使得网站在异常发生时并不会整个崩掉，从而影响到所有用户的访问，同时记录下异常的详细信息，以便于网站维护人员在异常发生后，可以准确定位异常所在位置和原因。本文使用过滤器的方式来实现全局异常捕获。网上也有很多类似的博文教程，我这里整理了一份日志打印比较完整的。 新建过滤器 在您的Util项目添加过滤器ExceptionLogAttribute.cs： using System; using System.Web; using System.Web.Mv
基于ASP.NET MVC的购物商城网站代码
最新发布
06-03
ASP.NET MVC提供异常过滤器，用于捕获和处理运行时错误，同时，使用NLog或Log4Net等工具进行日志记录，便于调试和问题排查。 10. **性能优化**： - **缓存策略**：使用Output Cache、Fragment Cache等来缓存静态...
asp.net MVC基础教学
02-21
ASP.NET MVC（Model-View-Controller）是一种广泛用于构建Web应用程序的框架，由Microsoft开发，它结合了MVC设计模式的灵活性与ASP.NET的强大功能。本基础教学将引导你逐步了解并掌握ASP.NET MVC的核心概念和技术。 ...
asp.net 异常处理跳转自定义错误页面Demo
06-17
本示例是关于如何在ASP.NET中实现异常处理，特别是如何在出现错误时跳转到自定义的404（页面未找到）和500（服务器内部错误）错误页面。下面我们将详细探讨这一主题。 首先，我们需要理解ASP.NET中的异常处理机制。...
如何使网站不出现从客户端(:)中检测到有潜在危险的 Request.Path 值这样类似的提示
热门推荐
sxf359的博客
11-08 4万+
从.net4.0开始，微软加入了对特殊字符的限制。默认的是7个特殊字符：requestPathInvalidCharacters = “<,>,*,%,&,:,\” 一旦有这7个特殊字符，则asp.net直接报有潜在危险的Request.Path,Request.Form,Request.QueryString等这样的错误 这是为什么出现的原因，可以在web.config中去除掉要限制的特殊字符
application Initialization设置导致处理程序ExtensionlessUrlHandler-Integrated-4.0在其模块列表中有一个错误模块问题的解决
sxf359的博客
07-28 3万+
近几天，本地电脑的一个网站每次编译后都会出现如下错误： HTTP 错误 500.21 - Internal Server Error 处理程序“ExtensionlessUrlHandler-Integrated-4.0”在其模块列表中有一个错误模块“ManagedPipelineHandler”
一例对一个或多个实体的验证失败。有关详细信息，请参阅“EntityValidationErrors”属性的解决
sxf359的博客
02-07 2万+
这个问题相信只要是做MVC的，都碰到过，也都知道错误的原因，就是触发了定义的实例字段校验规则。比如定义的不为空，但是为空了，或者定义的字段长度为50，但是超过50了。 可是有时虽然知道是这样，但是具体问题解决的时候还是无从下手。我最近就碰到一个，知道是在更新某个表的时候出现的这个问题。可是在本地无法具现此错误，这个错误是在特定条件发生的，我并不知道此特定发生条件是什么，很郁闷。 在网上找了下，
一例System.Data.SqlClient.SqlException: 对象名 'dbo.users' 无效问题的解决
sxf359的博客
11-20 2万+
在Dbcontext的继承类中发现这个定义： public virtual DbSet users { get; set; } 这个说明了context的users，注意这里后缀有一个s，它与数据库表user对应。因为这个在以前一直是好好的。从来没有出过错误。只是最近对对visual studio做了次更新导致的。想返回原来的vs版本也不可能。只能想办法解决。 通过比较出错项目，
无法将类型为“System.Int32”的对象强制转换为类型“System.String”
sxf359的博客
07-10 1万+
“/”应用程序中的服务器错误。 无法将类型为“System.Int32”的对象强制转换为类型“System.String”。 说明: 执行当前 Web 请求期间，出现未经处理的异常。请检查堆栈跟踪信息，以了解有关该错误以及代码中导致错误的出处的详细信息。  异常详细信息: System.InvalidCastException: 无法将类型为“System.Int32”的对象强制
fontawesome图标字体库组件在服务器上显示不出来图标的解决
sxf359的博客
07-31 1万+
这个组件在我所开发的网站中被大量使用，为网站增色不少。在本地测试的时候所有图标都能显示出来，可一到服务器上就显示不出来了。网上查列出了可能的原因。其一，IIS没有注册字体类型。经过检查，不存在这个问题。其二，css路径不对，其三引用字体路径不对。我有点纳闷，在本地可是能正确显示的。查看了本地和服务器fontawesome图标字体库css 及字体所在的目录都存在。这会是哪里的问题。使用浏览器的审查元
ASP.NET MVC错误处理策略与解决方案
ASP.NET MVC错误处理的文档主要讨论了如何在ASP.NET MVC框架中有效地管理和解决错误。文档提到了几个关键点，包括模型绑定错误、路由失败、控制器级别的错误处理，并提供了几种策略，如配置文件、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值