本文转自：http://www.binaryintellect.net/articles/5df6e275-1148-45a1-a8b3-0ba2c7c9cea1.aspx

In my previous article I explained how errors in an ASP.NET Core web application can be dealt with  using middleware. I also mentioned that time that you can also use exception  filters to handle errors. In this article I will explain how to do just that.

In ASP.NET MVC 5 you used the [HandleError] attribute and OnException()  controller method to deal with exceptions that arise in the actions of a  controller. In ASP.NET Core the process is bit different but the overall concept  is still the same. As you are probable aware of, filters sit in the ASP.NET Core  pipeline and allow you to execute a piece of code before or after an action  execution. To understand how errors can be handled in ASP.NET Core let's create  an exception filter called HandleException and then try to mimic the behavior of  [HandleError] of ASP.NET MVC 5.

Begin by creating a new ASP.NET web application. Then add a class to it named  HandleExceptionAttribute. This class needs to inherit from  ExceptionFilterAttribute base class. The complete code of this class is shown  below:

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
....
....public class HandleExceptionAttribute : ExceptionFilterAttribute
{public override void OnException(ExceptionContext context){var result = new ViewResult { ViewName = "Error" };var modelMetadata = new EmptyModelMetadataProvider();result.ViewData = new ViewDataDictionary(modelMetadata, context.ModelState);result.ViewData.Add("HandleException", context.Exception);context.Result = result;context.ExceptionHandled = true;}           }
}

The HandleExceptionAttribute class overrides the OnException() method of t he  base class. The OnException() method is called only when there is an unhandled  exception in an action. Inside, we create a ViewResult object that represents  the custom error page. It is assumed that the view representing the custom error  page is Error.cshtml. Later we will write some code to remove this hard-coding.

Then the code creates an empty object of EmptyModelMetadataProvider class.  This is required because we need to initialize the ViewData of the request and  add exception details in it. Then ViewData property of the ViewResult is  assigned to a new ViewDataDictionary object. While creating the  ViewDataDictionary the IModelMetadataProvider object created earlier is passed  to the constructor along with the context's ModelState.

We would like to store the exception details into the ViewData so that the  Error view can retrieve them and possibly display on the page. To facilitate  this HandleException key is added to the ViewData. The exception being thrown  can be obtained using context's Exception property.

Then Result property of context is set to the ViewResult we just configured.  Finally, ExceptionHandled property is set to true to indicate that the exception  need not be bubbled up any further.

Now open the HomeController and decorate the Index() action with the [HandleException]  attribute.

[HandleException]
public IActionResult Index()
{throw new Exception("This is some exception!!!");return View();
}

Also add Error.cshtml in Shared folder and write the following code to it:

@{ Exception ex = ViewData["HandleException"] as Exception;
}<h1>@ex.Message</h1><div>@ex.StackTrace</div>

As you can see the Error view can grab the exception details using the  HandleException key stored in the ViewData. The Message and StackTrace  properties of the Exception are then outputted on the page.

If you run the application you should see the error page like this:

So far so good. Now let's add a couple of features to our [HandleException]  attribute:

• The ViewName should be customizable
• There should be provision to handle only specific type of exceptions

Go ahead and add two public properties to the HandleExceptionAttribute class.  These properties are shown below:

public class HandleExceptionAttribute : ExceptionFilterAttribute
{public string ViewName { get; set; } = "Error";public Type ExceptionType { get; set; } = null;........
}

The ViewName property allows you to specify a custom view name that is then  used while forming the ViewResult. The ExceptionType property holds the Type of  the exception you wish to handle (say DivideByZeroException or FormatException).

Then modify the OnException() as shown below:

 public override void OnException(ExceptionContext context)
{if(this.ExceptionType != null){if(context.Exception.GetType() == this.ExceptionType){........}}else{........}
}

The OnException() method now checks whether a specific ExceptionType is to be  handled (non null value). If yes then it checks whether the exception being  thrown matches with that type (inner if block) and accordingly ViewResult is  configured. If no specific ExceptionType is to be checked then control directly  goes in the else block. The code in both the cases is shown below:

var result = new ViewResult { ViewName = this.ViewName };
var modelMetadata = new EmptyModelMetadataProvider();
result.ViewData = new ViewDataDictionary
(modelMetadata, context.ModelState);
result.ViewData.Add("HandleException", context.Exception);
context.Result = result;
context.ExceptionHandled = true;

This code is quite similar to what you wrote earlier. But this time it uses  the ViewName property while forming the ViewResult.

Now open the HomeController and change the [HandleException] attribute like  this:

[HandleException(ViewName ="CustomError",
ExceptionType =typeof(DivideByZeroException))]
public IActionResult Index()
{throw new Exception("This is some exception!!!");return View();
}

Now the [HandleException] attribute specifies two properties - ViewName and  ExceptionType. Since ExceptionType is set to the type of DivideByZeroException  the [HandleException] won't handle the error (because Index() throws a custom  Exception). So, rename Error.cshtml to CustomError.cshtml and throw a  DivideByZeroException. This time error gets trapped as expected.

It should be noted that [HandleException] can be applied on top of the  controller class itself rather than to individual actions.

[HandleException]
public class HomeController : Controller
{
....
....
}

More details about the ASP.NET Core filters can be found here.

That's it for now! Keep coding!!